diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..eae8fe3 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,70 @@ +# This file is part of EPOCH. +# File: CMakeLists.txt +# Author: Florent Teichteil-Königsbuch +# Contact: florent.teichteil@onera.fr +# +# EPOCH 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. +# +# EPOCH 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 EPOCH. If not, see . + +CMAKE_MINIMUM_REQUIRED (VERSION 2.8) + +PROJECT (EPOCH) +ENABLE_LANGUAGE(C CXX Fortran) + +SET (CMAKE_MODULE_PATH ${CMAKE_HOME_DIRECTORY}/config) + +INCLUDE (CheckIncludeFiles) + +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") + +##################### +# FIND DEPENDENCIES # +##################### + +FIND_PACKAGE (Boost 1.46.0 COMPONENTS program_options timer chrono filesystem system date_time timer unit_test_framework REQUIRED) +INCLUDE_DIRECTORIES (${Boost_INCLUDE_DIRS} ${SUITESPARSE_PATH}) +LINK_DIRECTORIES (${Boost_LIBRARY_DIRS}) +MESSAGE (STATUS "Found Boost version: " ${Boost_VERSION}) + +OPTION (BUILD_GUI "Build EPOCH's Graphical User Interface" OFF) +IF (BUILD_GUI) + FIND_PACKAGE (wxWidgetsCustom COMPONENTS base core aui xml REQUIRED) + SET (CMAKE_REQUIRED_INCLUDES_COPY ${CMAKE_REQUIRED_INCLUDES}) + LIST (APPEND CMAKE_REQUIRED_INCLUDES ${wxWidgets_INCLUDE_DIRS}) + CHECK_INCLUDE_FILES (wx/aui/tabdocmdi.h HAVE_TABDOCMDI_H) + SET (CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_COPY}) + FIND_PACKAGE (PLplot REQUIRED) + IF (NOT PLplot_wxwidgets_LIBRARY) + MESSAGE (FATAL_ERROR "PLplot wxwidgets bindings required to build the GUI") + ENDIF(NOT PLplot_wxwidgets_LIBRARY) +ENDIF (BUILD_GUI) + +OPTION (BUILD_DOC "Build Doxygen documentation" OFF) +IF (BUILD_DOC) + FIND_PACKAGE (Doxygen REQUIRED) +ENDIF (BUILD_DOC) + +################## +# COMPILES FILES # +################## + +ADD_SUBDIRECTORY (sdk) +ADD_SUBDIRECTORY (src) + +####################### +# BUILD DOCUMENTATION # +####################### + +IF (BUILD_DOC) + ADD_SUBDIRECTORY (doc) +ENDIF (BUILD_DOC) diff --git a/CeCILL-C.txt b/CeCILL-C.txt new file mode 100644 index 0000000..6569837 --- /dev/null +++ b/CeCILL-C.txt @@ -0,0 +1,1041 @@ + +CONTRAT DE LICENCE DE LOGICIEL LIBRE CeCILL-C + + + Avertissement + +Ce contrat est une licence de logiciel libre issue d'une concertation +entre ses auteurs afin que le respect de deux grands principes préside à +sa rédaction: + + * d'une part, le respect des principes de diffusion des logiciels + libres: accès au code source, droits étendus conférés aux + utilisateurs, + * d'autre part, la désignation d'un droit applicable, le droit + français, auquel elle est conforme, tant au regard du droit de la + responsabilité civile que du droit de la propriété intellectuelle + et de la protection qu'il offre aux auteurs et titulaires des + droits patrimoniaux sur un logiciel. + +Les auteurs de la licence CeCILL-C (pour Ce[a] C[nrs] I[nria] L[ogiciel] +L[ibre]) sont: + +Commissariat à l'Energie Atomique - CEA, établissement public de +recherche à caractère scientifique, technique et industriel, dont le +siège est situé 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris. + +Centre National de la Recherche Scientifique - CNRS, établissement +public à caractère scientifique et technologique, dont le siège est +situé 3 rue Michel-Ange, 75794 Paris cedex 16. + +Institut National de Recherche en Informatique et en Automatique - +INRIA, établissement public à caractère scientifique et technologique, +dont le siège est situé Domaine de Voluceau, Rocquencourt, BP 105, 78153 +Le Chesnay cedex. + + + Préambule + +Ce contrat est une licence de logiciel libre dont l'objectif est de +conférer aux utilisateurs la liberté de modifier et de réutiliser le +logiciel régi par cette licence. + +L'exercice de cette liberté est assorti d'une obligation de remettre à +la disposition de la communauté les modifications apportées au code +source du logiciel afin de contribuer à son évolution. + +L'accessibilité au code source et les droits de copie, de modification +et de redistribution qui découlent de ce contrat ont pour contrepartie +de n'offrir aux utilisateurs qu'une garantie limitée et de ne faire +peser sur l'auteur du logiciel, le titulaire des droits patrimoniaux et +les concédants successifs qu'une responsabilité restreinte. + +A cet égard l'attention de l'utilisateur est attirée sur les risques +associés au chargement, à l'utilisation, à la modification et/ou au +développement et à la reproduction du logiciel par l'utilisateur étant +donné sa spécificité de logiciel libre, qui peut le rendre complexe à +manipuler et qui le réserve donc à des développeurs ou des +professionnels avertis possédant des connaissances informatiques +approfondies. Les utilisateurs sont donc invités à charger et tester +l'adéquation du logiciel à leurs besoins dans des conditions permettant +d'assurer la sécurité de leurs systèmes et/ou de leurs données et, plus +généralement, à l'utiliser et l'exploiter dans les mêmes conditions de +sécurité. Ce contrat peut être reproduit et diffusé librement, sous +réserve de le conserver en l'état, sans ajout ni suppression de clauses. + +Ce contrat est susceptible de s'appliquer à tout logiciel dont le +titulaire des droits patrimoniaux décide de soumettre l'exploitation aux +dispositions qu'il contient. + + + Article 1 - DEFINITIONS + +Dans ce contrat, les termes suivants, lorsqu'ils seront écrits avec une +lettre capitale, auront la signification suivante: + +Contrat: désigne le présent contrat de licence, ses éventuelles versions +postérieures et annexes. + +Logiciel: désigne le logiciel sous sa forme de Code Objet et/ou de Code +Source et le cas échéant sa documentation, dans leur état au moment de +l'acceptation du Contrat par le Licencié. + +Logiciel Initial: désigne le Logiciel sous sa forme de Code Source et +éventuellement de Code Objet et le cas échéant sa documentation, dans +leur état au moment de leur première diffusion sous les termes du Contrat. + +Logiciel Modifié: désigne le Logiciel modifié par au moins une +Contribution Intégrée. + +Code Source: désigne l'ensemble des instructions et des lignes de +programme du Logiciel et auquel l'accès est nécessaire en vue de +modifier le Logiciel. + +Code Objet: désigne les fichiers binaires issus de la compilation du +Code Source. + +Titulaire: désigne le ou les détenteurs des droits patrimoniaux d'auteur +sur le Logiciel Initial. + +Licencié: désigne le ou les utilisateurs du Logiciel ayant accepté le +Contrat. + +Contributeur: désigne le Licencié auteur d'au moins une Contribution +Intégrée. + +Concédant: désigne le Titulaire ou toute personne physique ou morale +distribuant le Logiciel sous le Contrat. + +Contribution Intégrée: désigne l'ensemble des modifications, +corrections, traductions, adaptations et/ou nouvelles fonctionnalités +intégrées dans le Code Source par tout Contributeur. + +Module Lié: désigne un ensemble de fichiers sources y compris leur +documentation qui, sans modification du Code Source, permet de réaliser +des fonctionnalités ou services supplémentaires à ceux fournis par le +Logiciel. + +Logiciel Dérivé: désigne toute combinaison du Logiciel, modifié ou non, +et d'un Module Lié. + +Parties: désigne collectivement le Licencié et le Concédant. + +Ces termes s'entendent au singulier comme au pluriel. + + + Article 2 - OBJET + +Le Contrat a pour objet la concession par le Concédant au Licencié d'une +licence non exclusive, cessible et mondiale du Logiciel telle que +définie ci-après à l'article 5 pour toute la durée de protection des droits +portant sur ce Logiciel. + + + Article 3 - ACCEPTATION + +3.1 L'acceptation par le Licencié des termes du Contrat est réputée +acquise du fait du premier des faits suivants: + + * (i) le chargement du Logiciel par tout moyen notamment par + téléchargement à partir d'un serveur distant ou par chargement à + partir d'un support physique; + * (ii) le premier exercice par le Licencié de l'un quelconque des + droits concédés par le Contrat. + +3.2 Un exemplaire du Contrat, contenant notamment un avertissement +relatif aux spécificités du Logiciel, à la restriction de garantie et à +la limitation à un usage par des utilisateurs expérimentés a été mis à +disposition du Licencié préalablement à son acceptation telle que +définie à l'article 3.1 ci dessus et le Licencié reconnaît en avoir pris +connaissance. + + + Article 4 - ENTREE EN VIGUEUR ET DUREE + + + 4.1 ENTREE EN VIGUEUR + +Le Contrat entre en vigueur à la date de son acceptation par le Licencié +telle que définie en 3.1. + + + 4.2 DUREE + +Le Contrat produira ses effets pendant toute la durée légale de +protection des droits patrimoniaux portant sur le Logiciel. + + + Article 5 - ETENDUE DES DROITS CONCEDES + +Le Concédant concède au Licencié, qui accepte, les droits suivants sur +le Logiciel pour toutes destinations et pour la durée du Contrat dans +les conditions ci-après détaillées. + +Par ailleurs, si le Concédant détient ou venait à détenir un ou +plusieurs brevets d'invention protégeant tout ou partie des +fonctionnalités du Logiciel ou de ses composants, il s'engage à ne pas +opposer les éventuels droits conférés par ces brevets aux Licenciés +successifs qui utiliseraient, exploiteraient ou modifieraient le +Logiciel. En cas de cession de ces brevets, le Concédant s'engage à +faire reprendre les obligations du présent alinéa aux cessionnaires. + + + 5.1 DROIT D'UTILISATION + +Le Licencié est autorisé à utiliser le Logiciel, sans restriction quant +aux domaines d'application, étant ci-après précisé que cela comporte: + + 1. la reproduction permanente ou provisoire du Logiciel en tout ou + partie par tout moyen et sous toute forme. + + 2. le chargement, l'affichage, l'exécution, ou le stockage du + Logiciel sur tout support. + + 3. la possibilité d'en observer, d'en étudier, ou d'en tester le + fonctionnement afin de déterminer les idées et principes qui sont + à la base de n'importe quel élément de ce Logiciel; et ceci, + lorsque le Licencié effectue toute opération de chargement, + d'affichage, d'exécution, de transmission ou de stockage du + Logiciel qu'il est en droit d'effectuer en vertu du Contrat. + + + 5.2 DROIT DE MODIFICATION + +Le droit de modification comporte le droit de traduire, d'adapter, +d'arranger ou d'apporter toute autre modification au Logiciel et le +droit de reproduire le logiciel en résultant. Il comprend en particulier +le droit de créer un Logiciel Dérivé. + +Le Licencié est autorisé à apporter toute modification au Logiciel sous +réserve de mentionner, de façon explicite, son nom en tant qu'auteur de +cette modification et la date de création de celle-ci. + + + 5.3 DROIT DE DISTRIBUTION + +Le droit de distribution comporte notamment le droit de diffuser, de +transmettre et de communiquer le Logiciel au public sur tout support et +par tout moyen ainsi que le droit de mettre sur le marché à titre +onéreux ou gratuit, un ou des exemplaires du Logiciel par tout procédé. + +Le Licencié est autorisé à distribuer des copies du Logiciel, modifié ou +non, à des tiers dans les conditions ci-après détaillées. + + + 5.3.1 DISTRIBUTION DU LOGICIEL SANS MODIFICATION + +Le Licencié est autorisé à distribuer des copies conformes du Logiciel, +sous forme de Code Source ou de Code Objet, à condition que cette +distribution respecte les dispositions du Contrat dans leur totalité et +soit accompagnée: + + 1. d'un exemplaire du Contrat, + + 2. d'un avertissement relatif à la restriction de garantie et de + responsabilité du Concédant telle que prévue aux articles 8 + et 9, + +et que, dans le cas où seul le Code Objet du Logiciel est redistribué, +le Licencié permette un accès effectif au Code Source complet du +Logiciel pendant au moins toute la durée de sa distribution du Logiciel, +étant entendu que le coût additionnel d'acquisition du Code Source ne +devra pas excéder le simple coût de transfert des données. + + + 5.3.2 DISTRIBUTION DU LOGICIEL MODIFIE + +Lorsque le Licencié apporte une Contribution Intégrée au Logiciel, les +conditions de distribution du Logiciel Modifié en résultant sont alors +soumises à l'intégralité des dispositions du Contrat. + +Le Licencié est autorisé à distribuer le Logiciel Modifié sous forme de +code source ou de code objet, à condition que cette distribution +respecte les dispositions du Contrat dans leur totalité et soit +accompagnée: + + 1. d'un exemplaire du Contrat, + + 2. d'un avertissement relatif à la restriction de garantie et de + responsabilité du Concédant telle que prévue aux articles 8 + et 9, + +et que, dans le cas où seul le code objet du Logiciel Modifié est +redistribué, le Licencié permette un accès effectif à son code source +complet pendant au moins toute la durée de sa distribution du Logiciel +Modifié, étant entendu que le coût additionnel d'acquisition du code +source ne devra pas excéder le simple coût de transfert des données. + + + 5.3.3 DISTRIBUTION DU LOGICIEL DERIVE + +Lorsque le Licencié crée un Logiciel Dérivé, ce Logiciel Dérivé peut +être distribué sous un contrat de licence autre que le présent Contrat à +condition de respecter les obligations de mention des droits sur le +Logiciel telles que définies à l'article 6.4. Dans le cas où la création du +Logiciel Dérivé a nécessité une modification du Code Source le licencié +s'engage à ce que: + + 1. le Logiciel Modifié correspondant à cette modification soit régi + par le présent Contrat, + 2. les Contributions Intégrées dont le Logiciel Modifié résulte + soient clairement identifiées et documentées, + 3. le Licencié permette un accès effectif au code source du Logiciel + Modifié, pendant au moins toute la durée de la distribution du + Logiciel Dérivé, de telle sorte que ces modifications puissent + être reprises dans une version ultérieure du Logiciel, étant + entendu que le coût additionnel d'acquisition du code source du + Logiciel Modifié ne devra pas excéder le simple coût du transfert + des données. + + + 5.3.4 COMPATIBILITE AVEC LA LICENCE CeCILL + +Lorsqu'un Logiciel Modifié contient une Contribution Intégrée soumise au +contrat de licence CeCILL, ou lorsqu'un Logiciel Dérivé contient un +Module Lié soumis au contrat de licence CeCILL, les stipulations prévues +au troisième item de l'article 6.4 sont facultatives. + + + Article 6 - PROPRIETE INTELLECTUELLE + + + 6.1 SUR LE LOGICIEL INITIAL + +Le Titulaire est détenteur des droits patrimoniaux sur le Logiciel +Initial. Toute utilisation du Logiciel Initial est soumise au respect +des conditions dans lesquelles le Titulaire a choisi de diffuser son +oeuvre et nul autre n'a la faculté de modifier les conditions de +diffusion de ce Logiciel Initial. + +Le Titulaire s'engage à ce que le Logiciel Initial reste au moins régi +par le Contrat et ce, pour la durée visée à l'article 4.2. + + + 6.2 SUR LES CONTRIBUTIONS INTEGREES + +Le Licencié qui a développé une Contribution Intégrée est titulaire sur +celle-ci des droits de propriété intellectuelle dans les conditions +définies par la législation applicable. + + + 6.3 SUR LES MODULES LIES + +Le Licencié qui a développé un Module Lié est titulaire sur celui-ci des +droits de propriété intellectuelle dans les conditions définies par la +législation applicable et reste libre du choix du contrat régissant sa +diffusion dans les conditions définies à l'article 5.3.3. + + + 6.4 MENTIONS DES DROITS + +Le Licencié s'engage expressément: + + 1. à ne pas supprimer ou modifier de quelque manière que ce soit les + mentions de propriété intellectuelle apposées sur le Logiciel; + + 2. à reproduire à l'identique lesdites mentions de propriété + intellectuelle sur les copies du Logiciel modifié ou non; + + 3. à faire en sorte que l'utilisation du Logiciel, ses mentions de + propriété intellectuelle et le fait qu'il est régi par le Contrat + soient indiqués dans un texte facilement accessible notamment + depuis l'interface de tout Logiciel Dérivé. + +Le Licencié s'engage à ne pas porter atteinte, directement ou +indirectement, aux droits de propriété intellectuelle du Titulaire et/ou +des Contributeurs sur le Logiciel et à prendre, le cas échéant, à +l'égard de son personnel toutes les mesures nécessaires pour assurer le +respect des dits droits de propriété intellectuelle du Titulaire et/ou +des Contributeurs. + + + Article 7 - SERVICES ASSOCIES + +7.1 Le Contrat n'oblige en aucun cas le Concédant à la réalisation de +prestations d'assistance technique ou de maintenance du Logiciel. + +Cependant le Concédant reste libre de proposer ce type de services. Les +termes et conditions d'une telle assistance technique et/ou d'une telle +maintenance seront alors déterminés dans un acte séparé. Ces actes de +maintenance et/ou assistance technique n'engageront que la seule +responsabilité du Concédant qui les propose. + +7.2 De même, tout Concédant est libre de proposer, sous sa seule +responsabilité, à ses licenciés une garantie, qui n'engagera que lui, +lors de la redistribution du Logiciel et/ou du Logiciel Modifié et ce, +dans les conditions qu'il souhaite. Cette garantie et les modalités +financières de son application feront l'objet d'un acte séparé entre le +Concédant et le Licencié. + + + Article 8 - RESPONSABILITE + +8.1 Sous réserve des dispositions de l'article 8.2, le Licencié a la +faculté, sous réserve de prouver la faute du Concédant concerné, de +solliciter la réparation du préjudice direct qu'il subirait du fait du +Logiciel et dont il apportera la preuve. + +8.2 La responsabilité du Concédant est limitée aux engagements pris en +application du Contrat et ne saurait être engagée en raison notamment: +(i) des dommages dus à l'inexécution, totale ou partielle, de ses +obligations par le Licencié, (ii) des dommages directs ou indirects +découlant de l'utilisation ou des performances du Logiciel subis par le +Licencié et (iii) plus généralement d'un quelconque dommage indirect. En +particulier, les Parties conviennent expressément que tout préjudice +financier ou commercial (par exemple perte de données, perte de +bénéfices, perte d'exploitation, perte de clientèle ou de commandes, +manque à gagner, trouble commercial quelconque) ou toute action dirigée +contre le Licencié par un tiers, constitue un dommage indirect et +n'ouvre pas droit à réparation par le Concédant. + + + Article 9 - GARANTIE + +9.1 Le Licencié reconnaît que l'état actuel des connaissances +scientifiques et techniques au moment de la mise en circulation du +Logiciel ne permet pas d'en tester et d'en vérifier toutes les +utilisations ni de détecter l'existence d'éventuels défauts. L'attention +du Licencié a été attirée sur ce point sur les risques associés au +chargement, à l'utilisation, la modification et/ou au développement et à +la reproduction du Logiciel qui sont réservés à des utilisateurs avertis. + +Il relève de la responsabilité du Licencié de contrôler, par tous +moyens, l'adéquation du produit à ses besoins, son bon fonctionnement et +de s'assurer qu'il ne causera pas de dommages aux personnes et aux biens. + +9.2 Le Concédant déclare de bonne foi être en droit de concéder +l'ensemble des droits attachés au Logiciel (comprenant notamment les +droits visés à l'article 5). + +9.3 Le Licencié reconnaît que le Logiciel est fourni "en l'état" par le +Concédant sans autre garantie, expresse ou tacite, que celle prévue à +l'article 9.2 et notamment sans aucune garantie sur sa valeur commerciale, +son caractère sécurisé, innovant ou pertinent. + +En particulier, le Concédant ne garantit pas que le Logiciel est exempt +d'erreur, qu'il fonctionnera sans interruption, qu'il sera compatible +avec l'équipement du Licencié et sa configuration logicielle ni qu'il +remplira les besoins du Licencié. + +9.4 Le Concédant ne garantit pas, de manière expresse ou tacite, que le +Logiciel ne porte pas atteinte à un quelconque droit de propriété +intellectuelle d'un tiers portant sur un brevet, un logiciel ou sur tout +autre droit de propriété. Ainsi, le Concédant exclut toute garantie au +profit du Licencié contre les actions en contrefaçon qui pourraient être +diligentées au titre de l'utilisation, de la modification, et de la +redistribution du Logiciel. Néanmoins, si de telles actions sont +exercées contre le Licencié, le Concédant lui apportera son aide +technique et juridique pour sa défense. Cette aide technique et +juridique est déterminée au cas par cas entre le Concédant concerné et +le Licencié dans le cadre d'un protocole d'accord. Le Concédant dégage +toute responsabilité quant à l'utilisation de la dénomination du +Logiciel par le Licencié. Aucune garantie n'est apportée quant à +l'existence de droits antérieurs sur le nom du Logiciel et sur +l'existence d'une marque. + + + Article 10 - RESILIATION + +10.1 En cas de manquement par le Licencié aux obligations mises à sa +charge par le Contrat, le Concédant pourra résilier de plein droit le +Contrat trente (30) jours après notification adressée au Licencié et +restée sans effet. + +10.2 Le Licencié dont le Contrat est résilié n'est plus autorisé à +utiliser, modifier ou distribuer le Logiciel. Cependant, toutes les +licences qu'il aura concédées antérieurement à la résiliation du Contrat +resteront valides sous réserve qu'elles aient été effectuées en +conformité avec le Contrat. + + + Article 11 - DISPOSITIONS DIVERSES + + + 11.1 CAUSE EXTERIEURE + +Aucune des Parties ne sera responsable d'un retard ou d'une défaillance +d'exécution du Contrat qui serait dû à un cas de force majeure, un cas +fortuit ou une cause extérieure, telle que, notamment, le mauvais +fonctionnement ou les interruptions du réseau électrique ou de +télécommunication, la paralysie du réseau liée à une attaque +informatique, l'intervention des autorités gouvernementales, les +catastrophes naturelles, les dégâts des eaux, les tremblements de terre, +le feu, les explosions, les grèves et les conflits sociaux, l'état de +guerre... + +11.2 Le fait, par l'une ou l'autre des Parties, d'omettre en une ou +plusieurs occasions de se prévaloir d'une ou plusieurs dispositions du +Contrat, ne pourra en aucun cas impliquer renonciation par la Partie +intéressée à s'en prévaloir ultérieurement. + +11.3 Le Contrat annule et remplace toute convention antérieure, écrite +ou orale, entre les Parties sur le même objet et constitue l'accord +entier entre les Parties sur cet objet. Aucune addition ou modification +aux termes du Contrat n'aura d'effet à l'égard des Parties à moins +d'être faite par écrit et signée par leurs représentants dûment habilités. + +11.4 Dans l'hypothèse où une ou plusieurs des dispositions du Contrat +s'avèrerait contraire à une loi ou à un texte applicable, existants ou +futurs, cette loi ou ce texte prévaudrait, et les Parties feraient les +amendements nécessaires pour se conformer à cette loi ou à ce texte. +Toutes les autres dispositions resteront en vigueur. De même, la +nullité, pour quelque raison que ce soit, d'une des dispositions du +Contrat ne saurait entraîner la nullité de l'ensemble du Contrat. + + + 11.5 LANGUE + +Le Contrat est rédigé en langue française et en langue anglaise, ces +deux versions faisant également foi. + + + Article 12 - NOUVELLES VERSIONS DU CONTRAT + +12.1 Toute personne est autorisée à copier et distribuer des copies de +ce Contrat. + +12.2 Afin d'en préserver la cohérence, le texte du Contrat est protégé +et ne peut être modifié que par les auteurs de la licence, lesquels se +réservent le droit de publier périodiquement des mises à jour ou de +nouvelles versions du Contrat, qui posséderont chacune un numéro +distinct. Ces versions ultérieures seront susceptibles de prendre en +compte de nouvelles problématiques rencontrées par les logiciels libres. + +12.3 Tout Logiciel diffusé sous une version donnée du Contrat ne pourra +faire l'objet d'une diffusion ultérieure que sous la même version du +Contrat ou une version postérieure. + + + Article 13 - LOI APPLICABLE ET COMPETENCE TERRITORIALE + +13.1 Le Contrat est régi par la loi française. Les Parties conviennent +de tenter de régler à l'amiable les différends ou litiges qui +viendraient à se produire par suite ou à l'occasion du Contrat. + +13.2 A défaut d'accord amiable dans un délai de deux (2) mois à compter +de leur survenance et sauf situation relevant d'une procédure d'urgence, +les différends ou litiges seront portés par la Partie la plus diligente +devant les Tribunaux compétents de Paris. + + +Version 1.0 du 2006-09-05. + +--- + + +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. diff --git a/Copyright b/Copyright deleted file mode 100644 index a0fec18..0000000 --- a/Copyright +++ /dev/null @@ -1,10 +0,0 @@ -Copyright (c) 2017-2018 IRT AESE (IRT Saint Exupéry). -All rights reserved. This program and the accompanying materials -are made available under the terms of the -CeCILL-C V1 - -which accompanies this distribution, and is available at -http://www.cecill.info/licences/Licence_CeCILL-C_V1-fr.html - -Contributors: -Alexandre Albore – Initial contribution \ No newline at end of file diff --git a/LGPL-v2.txt b/LGPL-v2.txt new file mode 100644 index 0000000..f4fac14 --- /dev/null +++ b/LGPL-v2.txt @@ -0,0 +1,481 @@ + GNU LIBRARY GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1991 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the library GPL. It is + numbered 2 because it goes with version 2 of the ordinary GPL.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Library General Public License, applies to some +specially designated Free Software Foundation software, and to any +other libraries whose authors decide to use it. You can use it for +your libraries, 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 +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if +you distribute copies of the library, or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link a program with the library, you must provide +complete object files to the recipients so that they can relink them +with the library, after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + Our method of protecting your rights has two steps: (1) copyright +the library, and (2) offer you this license which gives you legal +permission to copy, distribute and/or modify the library. + + Also, for each distributor's protection, we want to make certain +that everyone understands that there is no warranty for this free +library. If the library is modified by someone else and passed on, we +want its recipients to know that what they have is not the original +version, so that any problems introduced by others will not reflect on +the original authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that companies distributing free +software will individually obtain patent licenses, thus in effect +transforming the program into proprietary software. To prevent this, +we have made it clear that any patent must be licensed for everyone's +free use or not licensed at all. + + Most GNU software, including some libraries, is covered by the ordinary +GNU General Public License, which was designed for utility programs. This +license, the GNU Library General Public License, applies to certain +designated libraries. This license is quite different from the ordinary +one; be sure to read it in full, and don't assume that anything in it is +the same as in the ordinary license. + + The reason we have a separate public license for some libraries is that +they blur the distinction we usually make between modifying or adding to a +program and simply using it. Linking a program with a library, without +changing the library, is in some sense simply using the library, and is +analogous to running a utility program or application program. However, in +a textual and legal sense, the linked executable is a combined work, a +derivative of the original library, and the ordinary General Public License +treats it as such. + + Because of this blurred distinction, using the ordinary General +Public License for libraries did not effectively promote software +sharing, because most developers did not use the libraries. We +concluded that weaker conditions might promote sharing better. + + However, unrestricted linking of non-free programs would deprive the +users of those programs of all benefit from the free status of the +libraries themselves. This Library General Public License is intended to +permit developers of non-free programs to use free libraries, while +preserving your freedom as a user of such programs to change the free +libraries that are incorporated in them. (We have not seen how to achieve +this as regards changes in header files, but we have achieved it as regards +changes in the actual functions of the Library.) The hope is that this +will lead to faster development of free libraries. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, while the latter only +works together with the library. + + Note that it is possible for a library to be covered by the ordinary +General Public License rather than by this special one. + + GNU LIBRARY GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library which +contains a notice placed by the copyright holder or other authorized +party saying it may be distributed under the terms of this Library +General Public License (also called "this License"). Each licensee is +addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also compile or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + c) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + d) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the source code distributed need not include anything that is normally +distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Library General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/LICENSES.md b/LICENSES.md new file mode 100644 index 0000000..89f27f1 --- /dev/null +++ b/LICENSES.md @@ -0,0 +1,143 @@ +# Copyrights and licensing + +## Altarica / Fiacre translator +The Altarica / Fiacre translator is copyright 2015-2017 ONERA (the French Aerospace Lab) and IRT Saint Exupéry. +All rights reserved. It is distributed under the terms of the CeCILL-C license. +See the accompanying file CeCILL-C.txt, +or . + +## Third party components + +### Boost under the terms of BOOST license : + + Boost Software License - Version 1.0 - August 17th, 2003 + + Permission is hereby granted, free of charge, to any person or organization + obtaining a copy of the software and accompanying documentation covered by + this license (the "Software") to use, reproduce, display, distribute, + execute, and transmit the Software, and to prepare derivative works of the + Software, and to permit third-parties to whom the Software is furnished to + do so, all subject to the following: + + The copyright notices in the Software and this entire statement, including + the above license grant, this restriction and the following disclaimer, + must be included in all copies of the Software, in whole or in part, and + all derivative works of the Software, unless such copies or derivative + works are solely in the form of machine-executable object code generated by + a source language processor. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT + SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE + FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +### Buddy 2.4 + + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. + +### WxScintilla-1.69.2 from codelite-2.7.0.4375 and Wxshapeframework 1.9.2 + + https://opensource.org/licenses/WXwindows + + wxWindows Library Licence, Version 3.1 + ====================================== + + Copyright (c) 1998-2005 Julian Smart, Robert Roebling et al + + Everyone is permitted to copy and distribute verbatim copies + of this licence document, but changing it is not allowed. + + WXWINDOWS LIBRARY LICENCE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + This library is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public Licence as published by + the Free Software Foundation; either version 2 of the Licence, or (at your + option) any later version. + + This library 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 Library General Public + Licence for more details. + + You should have received a copy of the GNU Library General Public Licence + along with this software, usually in a file named COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth + Floor, Boston, MA 02110-1301 USA. + + EXCEPTION NOTICE + + 1. As a special exception, the copyright holders of this library give + permission for additional uses of the text contained in this release of the + library as licenced under the wxWindows Library Licence, applying either + version 3.1 of the Licence, or (at your option) any later version of the + Licence as published by the copyright holders of version 3.1 of the Licence + document. + + 2. The exception is that you may use, copy, link, modify and distribute + under your own terms, binary object code versions of works based on the + Library. + + 3. If you copy code from files distributed under the terms of the GNU + General Public Licence or the GNU Library General Public Licence into a + copy of this library, as this licence permits, the exception does not apply + to the code that you add in this way. To avoid misleading anyone as to the + status of such modified files, you must delete this exception notice from + such code and/or adjust the licensing conditions notice accordingly. + + 4. If you write modifications of your own for this library, it is your + choice whether to permit this exception to apply to your modifications. If + you do not wish that, you must delete the exception notice from such code + and/or adjust the licensing conditions notice accordingly. + +### Scintilla 1.62 + + License for Scintilla and SciTE + + Copyright 1998-2003 by Neil Hodgson + + All Rights Reserved + + Permission to use, copy, modify, and distribute this software and its + documentation for any purpose and without fee is hereby granted, + provided that the above copyright notice appear in all copies and that + both that copyright notice and this permission notice appear in + supporting documentation. + + NEIL HODGSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS, IN NO EVENT SHALL NEIL HODGSON BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE + OR PERFORMANCE OF THIS SOFTWARE. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..d7b1789 --- /dev/null +++ b/README.md @@ -0,0 +1,17 @@ +# What are the prerequisites to build altarica_epoch? +On Linux Ubuntu 16.04.1 LTS, the following packages are required to build altarica_epoch: build-essential, flex, bison, cmake, gcc/g++/gfortran 5.4.0, libsuitesparse-dev, libxml-dev, libglib2.0-dev, libsigc++-2.0-dev, libglibmm-2.4-dev, libxml++2.6-dev and pkg-config. + + sudo apt install build-essential flex bison cmake gcc-5 g++-5 gfortran-5 libsuitesparse-dev libxml-dev libglib2.0-dev libsigc++-2.0-dev libglibmm-2.4-dev libxml++2.6-dev pkg-config + +# How to build altarica_epoch? +altarica_epoch uses CMake build system. It can be built with the following commands: + + cd altarica_epoch + cmake ./CMakeList.txt + make + +# How to launch altarica_epoch? +You can get the inline help with: + + src/console/epochnogui --help + \ No newline at end of file diff --git a/TODO b/TODO new file mode 100644 index 0000000..f346e7e --- /dev/null +++ b/TODO @@ -0,0 +1,3 @@ +- Min/Max in renamings +- Special handlings of boolean types in PRISM operators creators + diff --git a/config/FindGlib.cmake b/config/FindGlib.cmake new file mode 100644 index 0000000..d3547d5 --- /dev/null +++ b/config/FindGlib.cmake @@ -0,0 +1,39 @@ +# - Try to find Glib-2.0 (with gobject) +# Once done, this will define +# +# Glib_FOUND - system has Glib +# Glib_INCLUDE_DIRS - the Glib include directories +# Glib_LIBRARIES - link these to use Glib + +include(LibFindMacros) + +# Use pkg-config to get hints about paths +libfind_pkg_check_modules(Glib_PKGCONF glib-2.0) + +# Main include dir +find_path(Glib_INCLUDE_DIR + NAMES glib.h + PATHS ${Glib_PKGCONF_INCLUDE_DIRS} + PATH_SUFFIXES glib-2.0 +) + +# Glib-related libraries also use a separate config header, which is in lib dir +find_path(GlibConfig_INCLUDE_DIR + NAMES glibconfig.h + PATHS ${Glib_PKGCONF_INCLUDE_DIRS} /usr + PATH_SUFFIXES lib/glib-2.0/include +) + +# Finally the library itself +find_library(Glib_LIBRARY + NAMES glib-2.0 + PATHS ${Glib_PKGCONF_LIBRARY_DIRS} +) + +# Set the include dir variables and the libraries and let libfind_process do the rest. +# NOTE: Singular variables for this library, plural for libraries this this lib depends on. +set(Glib_PROCESS_INCLUDES Glib_INCLUDE_DIR GlibConfig_INCLUDE_DIR) +set(Glib_PROCESS_LIBS Glib_LIBRARY) +libfind_process(Glib) + + diff --git a/config/FindGlibmm.cmake b/config/FindGlibmm.cmake new file mode 100644 index 0000000..1615bc2 --- /dev/null +++ b/config/FindGlibmm.cmake @@ -0,0 +1,38 @@ +# - Try to find Glibmm-2.4 +# Once done, this will define +# +# Glibmm_FOUND - system has Glibmm +# Glibmm_INCLUDE_DIRS - the Glibmm include directories +# Glibmm_LIBRARIES - link these to use Glibmm + +include(LibFindMacros) + +# Dependencies +libfind_package(Glibmm Glib) +libfind_package(Glibmm SigC++) + +# Use pkg-config to get hints about paths +libfind_pkg_check_modules(Glibmm_PKGCONF glibmm-2.4) + +# Main include dir +find_path(Glibmm_INCLUDE_DIR + NAMES glibmm/main.h + PATHS ${Glibmm_PKGCONF_INCLUDE_DIRS} + PATH_SUFFIXES glibmm-2.4 +) + +# Glib-related libraries also use a separate config header, which is in lib dir +find_path(GlibmmConfig_INCLUDE_DIR + NAMES glibmmconfig.h + PATHS ${Glibmm_PKGCONF_INCLUDE_DIRS} /usr + PATH_SUFFIXES lib/glibmm-2.4/include +) + +libfind_library(Glibmm glibmm 2.4) + +# Set the include dir variables and the libraries and let libfind_process do the rest. +# NOTE: Singular variables for this library, plural for libraries this this lib depends on. +set(Glibmm_PROCESS_INCLUDES Glibmm_INCLUDE_DIR GlibmmConfig_INCLUDE_DIR Glib_INCLUDE_DIRS SigC++_INCLUDE_DIRS) +set(Glibmm_PROCESS_LIBS Glibmm_LIBRARY Glib_LIBRARIES SigC++_LIBRARIES) +libfind_process(Glibmm) + diff --git a/config/FindLibXML++.cmake b/config/FindLibXML++.cmake new file mode 100644 index 0000000..7d6c47f --- /dev/null +++ b/config/FindLibXML++.cmake @@ -0,0 +1,41 @@ +# - Try to find LibXML++ 2.6 +# Once done, this will define +# +# LibXML++_FOUND - system has LibXML++ +# LibXML++_INCLUDE_DIRS - the LibXML++ include directories +# LibXML++_LIBRARIES - link these to use LibXML++ + +include(LibFindMacros) + +# Dependencies +libfind_package(LibXML++ LibXML2) +libfind_package(LibXML++ Glibmm) + +# Use pkg-config to get hints about paths +libfind_pkg_check_modules(LibXML++_PKGCONF libxml++-2.6) + +# Main include dir +find_path(LibXML++_INCLUDE_DIR + NAMES libxml++/libxml++.h + PATHS ${LibXML++_PKGCONF_INCLUDE_DIRS} + PATH_SUFFIXES libxml++-2.6 + ) + +# Glib-related libraries also use a separate config header, which is in lib dir +find_path(LibXML++Config_INCLUDE_DIR + NAMES libxml++config.h + PATHS ${LibXML++_PKGCONF_INCLUDE_DIRS} /usr + PATH_SUFFIXES lib/libxml++-2.6/include + ) + +# Finally the library itself +find_library(LibXML++_LIBRARY + NAMES xml++-2.6 + PATHS ${LibXML++_PKGCONF_LIBRARY_DIRS} + ) + +# Set the include dir variables and the libraries and let libfind_process do the rest. +# NOTE: Singular variables for this library, plural for libraries this this lib depends on. +set(LibXML++_PROCESS_INCLUDES LibXML++_INCLUDE_DIR LibXML++Config_INCLUDE_DIR LibXML2_INCLUDE_DIRS Glibmm_INCLUDE_DIRS) +set(LibXML++_PROCESS_LIBS LibXML++_LIBRARY LibXML2_LIBRARIES Glibmm_LIBRARIES) +libfind_process(LibXML++) diff --git a/config/FindLibXML2.cmake b/config/FindLibXML2.cmake new file mode 100644 index 0000000..013b278 --- /dev/null +++ b/config/FindLibXML2.cmake @@ -0,0 +1,90 @@ +# - Try to find libxml2 +# Once done this will define +# +# LibXML2_FOUND - system has xml2 +# LibXML2_INCLUDE_DIRS - the xml2 include directory +# LibXML2_LIBRARIES - Link these to use xml2 +# LibXML2_DEFINITIONS - Compiler switches required for using xml2 +# +# Copyright (c) 2008 Andreas Schneider +# Modified for other libraries by Lasse Kärkkäinen +# +# Redistribution and use is allowed according to the terms of the New +# BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. +# + + +if (LibXML2_LIBRARIES AND LibXML2_INCLUDE_DIRS) + # in cache already + set(LibXML2_FOUND TRUE) +else (LibXML2_LIBRARIES AND LibXML2_INCLUDE_DIRS) + # use pkg-config to get the directories and then use these values + # in the FIND_PATH() and FIND_LIBRARY() calls + if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4) + include(UsePkgConfig) + pkgconfig(libxml-2.0 _LibXML2_INCLUDEDIR _LibXML2_LIBDIR _LibXML2_LDFLAGS _LibXML2_CFLAGS) + else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4) + find_package(PkgConfig) + if (PKG_CONFIG_FOUND) + pkg_check_modules(_LIBXML2 libxml-2.0) + endif (PKG_CONFIG_FOUND) + endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4) + find_path(LibXML2_INCLUDE_DIR + NAMES + libxml/xpath.h + PATHS + ${_LibXML2_INCLUDEDIR} + /usr/include + /usr/local/include + /opt/local/include + /sw/include + PATH_SUFFIXES + libxml2 + ) + + find_library(LibXML2_LIBRARY + NAMES + xml2 + PATHS + ${_LibXML2_LIBDIR} + /usr/lib + /usr/local/lib + /opt/local/lib + /sw/lib + ) + + if (LibXML2_LIBRARY) + set(LibXML2_FOUND TRUE) + endif (LibXML2_LIBRARY) + + set(LibXML2_INCLUDE_DIRS + ${LibXML2_INCLUDE_DIR} + ) + + if (LibXML2_FOUND) + set(LibXML2_LIBRARIES + ${LibXML2_LIBRARIES} + ${LibXML2_LIBRARY} + ) + endif (LibXML2_FOUND) + + if (LibXML2_INCLUDE_DIRS AND LibXML2_LIBRARIES) + set(LibXML2_FOUND TRUE) + endif (LibXML2_INCLUDE_DIRS AND LibXML2_LIBRARIES) + + if (LibXML2_FOUND) + if (NOT LibXML2_FIND_QUIETLY) + message(STATUS "Found libxml2: ${LibXML2_LIBRARY}") + endif (NOT LibXML2_FIND_QUIETLY) + else (LibXML2_FOUND) + if (LibXML2_FIND_REQUIRED) + message(FATAL_ERROR "Could not find libxml2") + endif (LibXML2_FIND_REQUIRED) + endif (LibXML2_FOUND) + + # show the LibXML2_INCLUDE_DIRS and LibXML2_LIBRARIES variables only in the advanced view + mark_as_advanced(LibXML2_INCLUDE_DIRS LibXML2_LIBRARIES) + +endif (LibXML2_LIBRARIES AND LibXML2_INCLUDE_DIRS) + diff --git a/config/FindPLplot.cmake b/config/FindPLplot.cmake new file mode 100644 index 0000000..006a102 --- /dev/null +++ b/config/FindPLplot.cmake @@ -0,0 +1,75 @@ +# Find PLplot header and library. + +# This module defines the following uncached variables: +# PLplot_FOUND, if false, do not try to use PLplot. +# PLplot_INCLUDE_DIRS, where to find plplot.h. +# PLplot_LIBRARIES, the libraries to link against to use PLplot +# PLplot_LIBRARY_DIRS, the directory where the PLplot library is found. + +FIND_PATH( + PLplot_INCLUDE_DIR + NAMES plplot.h + PATHS /usr/local/include /usr/include + PATH_SUFFIXES plplot +) + +IF( PLplot_INCLUDE_DIR ) + find_library( PLplot_LIBRARY + NAMES plplotd + PATHS /usr/local/lib /usr/lib + ) + if(PLplot_LIBRARY) + set( PLplot_LIBRARY_DIR "" ) + get_filename_component(PLplot_LIBRARY_DIRS ${PLplot_LIBRARY} PATH) + # Set uncached variables as per standard. + set(PLplot_FOUND ON) + set(PLplot_INCLUDE_DIRS ${PLplot_INCLUDE_DIR}) + set(PLplot_LIBRARIES ${PLplot_LIBRARY}) + endif(PLplot_LIBRARY) + + # find cxx bindings + find_library( PLplot_cxx_LIBRARY + NAMES plplotcxxd + PATHS /usr/local/lib /usr/lib + ) + if( PLplot_cxx_LIBRARY ) + set( PLplot_LIBRARIES ${PLplot_LIBRARIES} ${PLplot_cxx_LIBRARY} ) + endif( PLplot_cxx_LIBRARY ) + + # find f77 bindings + find_library( PLplot_f77_LIBRARY + NAMES plplotf77d + PATHS /usr/local/lib /usr/lib + ) + if( PLplot_f77_LIBRARY ) + set( PLplot_LIBRARIES ${PLplot_LIBRARIES} ${PLplot_f77_LIBRARY} ) + endif( PLplot_f77_LIBRARY ) + + # find f90 bindings + find_library( PLplot_f90_LIBRARY + NAMES plplotf90d + PATHS /usr/local/lib /usr/lib + ) + if( PLplot_f90_LIBRARY ) + set( PLplot_LIBRARIES ${PLplot_LIBRARIES} ${PLplot_f90_LIBRARY} ) + endif( PLplot_f90_LIBRARY ) + + # find wxwidgets bindings + find_library( PLplot_wxwidgets_LIBRARY + NAMES plplotwxwidgetsd + PATHS /usr/local/lib /usr/lib + ) + if( PLplot_wxwidgets_LIBRARY ) + set( PLplot_LIBRARIES ${PLplot_LIBRARIES} ${PLplot_wxwidgets_LIBRARY} ) + endif( PLplot_wxwidgets_LIBRARY ) +endif(PLplot_INCLUDE_DIR) + +if(PLplot_FOUND) + if(NOT PLplot_FIND_QUIETLY) + message(STATUS "FindPLplot: Found both PLplot headers and library") + endif(NOT PLplot_FIND_QUIETLY) +else(PLplot_FOUND) + if(PLplot_FIND_REQUIRED) + message(FATAL_ERROR "FindPLplot: Could not find PLplot headers or library") + endif(PLplot_FIND_REQUIRED) +endif(PLplot_FOUND) diff --git a/config/FindSigC++.cmake b/config/FindSigC++.cmake new file mode 100644 index 0000000..7d34d9e --- /dev/null +++ b/config/FindSigC++.cmake @@ -0,0 +1,34 @@ +# - Try to find SigC++-2.0 +# Once done, this will define +# +# SigC++_FOUND - system has SigC++ +# SigC++_INCLUDE_DIRS - the SigC++ include directories +# SigC++_LIBRARIES - link these to use SigC++ + +include(LibFindMacros) + +# Use pkg-config to get hints about paths +libfind_pkg_check_modules(SigC++_PKGCONF sigc++-2.0) + +# Main include dir +find_path(SigC++_INCLUDE_DIR + NAMES sigc++/sigc++.h + PATHS ${SigC++_PKGCONF_INCLUDE_DIRS} + PATH_SUFFIXES sigc++-2.0 +) + +# Glib-related libraries also use a separate config header, which is in lib dir +find_path(SigC++Config_INCLUDE_DIR + NAMES sigc++config.h + PATHS ${SigC++_PKGCONF_INCLUDE_DIRS} /usr + PATH_SUFFIXES lib/sigc++-2.0/include +) + +libfind_library(SigC++ sigc 2.0) + +# Set the include dir variables and the libraries and let libfind_process do the rest. +# NOTE: Singular variables for this library, plural for libraries this this lib depends on. +set(SigC++_PROCESS_INCLUDES SigC++_INCLUDE_DIR SigC++Config_INCLUDE_DIR) +set(SigC++_PROCESS_LIBS SigC++_LIBRARY) +libfind_process(SigC++) + diff --git a/config/FindUMFPACK.cmake b/config/FindUMFPACK.cmake new file mode 100644 index 0000000..238f203 --- /dev/null +++ b/config/FindUMFPACK.cmake @@ -0,0 +1,100 @@ +SET( UMFPACK_FOUND "NO" ) + +if (UMFPACK_INCLUDES AND UMFPACK_LIBRARIES) + set(UMFPACK_FIND_QUIETLY TRUE) +endif (UMFPACK_INCLUDES AND UMFPACK_LIBRARIES) + +find_package(BLAS REQUIRED) + +if(BLAS_FOUND) + + find_path(UMFPACK_INCLUDES + NAMES + umfpack.h + PATHS + $ENV{UMFPACKDIR} + ${INCLUDE_INSTALL_DIR} + PATH_SUFFIXES + suitesparse + ) + + find_library(UMFPACK_LIBRARIES umfpack PATHS $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + + if(UMFPACK_LIBRARIES) + + get_filename_component(UMFPACK_LIBDIR ${UMFPACK_LIBRARIES} PATH) + + find_library(AMD_LIBRARY amd PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (AMD_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${AMD_LIBRARY}) + else (AMD_LIBRARY) + MESSAGE ( FATAL_ERROR "AMD library not found!" ) + set(UMFPACK_LIBRARIES) + endif (AMD_LIBRARY) + + find_library(CHOLMOD_LIBRARY cholmod PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (CHOLMOD_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${CHOLMOD_LIBRARY}) + else (CHOLMOD_LIBRARY) + MESSAGE ( FATAL_ERROR "CHOLAMD library not found!" ) + set(UMFPACK_LIBRARIES) + endif (CHOLMOD_LIBRARY) + + find_library(COLAMD_LIBRARY colamd PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (COLAMD_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${COLAMD_LIBRARY}) + else (COLAMD_LIBRARY) + MESSAGE ( FATAL_ERROR "COLAMD library not found!" ) + set(UMFPACK_LIBRARIES) + endif (COLAMD_LIBRARY) + + find_library(CAMD_LIBRARY camd PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (CAMD_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${CAMD_LIBRARY}) + else (CAMD_LIBRARY) + MESSAGE ( FATAL_ERROR "CAMD library not found!" ) + set(UMFPACK_LIBRARIES) + endif (CAMD_LIBRARY) + + find_library(CCOLAMD_LIBRARY ccolamd PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (CCOLAMD_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${CCOLAMD_LIBRARY}) + else (CCOLAMD_LIBRARY) + MESSAGE ( FATAL_ERROR "CCOLAMD library not found!" ) + set(UMFPACK_LIBRARIES) + endif (CCOLAMD_LIBRARY) + + find_library(METIS_LIBRARY metis PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (METIS_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${METIS_LIBRARY}) + else (METIS_LIBRARY) + MESSAGE ( STATUS "METIS library not found!" ) +# set(UMFPACK_LIBRARIES) + endif (METIS_LIBRARY) + + find_library(SPARSECONFIG_LIBRARY suitesparseconfig PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) + if (SPARSECONFIG_LIBRARY) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${SPARSECONFIG_LIBRARY}) + else (SPARSECONFIG_LIBRARY) + message ("paths : " ${PATHS}) + MESSAGE ( FATAL_ERROR "SPARSECONFIG library not found!" ) + set(UMFPACK_LIBRARIES) + endif (SPARSECONFIG_LIBRARY) + + + endif(UMFPACK_LIBRARIES) + + if(UMFPACK_LIBRARIES) + set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${BLAS_LIBRARIES} gfortran) + SET( UMFPACK_FOUND "YES" ) + endif(UMFPACK_LIBRARIES) + +endif(BLAS_FOUND) + + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(UMFPACK DEFAULT_MSG + UMFPACK_INCLUDES UMFPACK_LIBRARIES) + +mark_as_advanced(UMFPACK_INCLUDES UMFPACK_LIBRARIES AMD_LIBRARY COLAMD_LIBRARY) + diff --git a/config/FindwxWidgetsCustom.cmake b/config/FindwxWidgetsCustom.cmake new file mode 100644 index 0000000..b964006 --- /dev/null +++ b/config/FindwxWidgetsCustom.cmake @@ -0,0 +1,1086 @@ +#.rst: +# FindwxWidgets +# ------------- +# +# Find a wxWidgets (a.k.a., wxWindows) installation. +# +# This module finds if wxWidgets is installed and selects a default +# configuration to use. wxWidgets is a modular library. To specify the +# modules that you will use, you need to name them as components to the +# package: +# +# find_package(wxWidgets COMPONENTS core base ...) +# +# There are two search branches: a windows style and a unix style. For +# windows, the following variables are searched for and set to defaults +# in case of multiple choices. Change them if the defaults are not +# desired (i.e., these are the only variables you should change to +# select a configuration): +# +# :: +# +# wxWidgets_ROOT_DIR - Base wxWidgets directory +# (e.g., C:/wxWidgets-2.6.3). +# wxWidgets_LIB_DIR - Path to wxWidgets libraries +# (e.g., C:/wxWidgets-2.6.3/lib/vc_lib). +# wxWidgets_CONFIGURATION - Configuration to use +# (e.g., msw, mswd, mswu, mswunivud, etc.) +# wxWidgets_EXCLUDE_COMMON_LIBRARIES +# - Set to TRUE to exclude linking of +# commonly required libs (e.g., png tiff +# jpeg zlib regex expat). +# +# +# +# For unix style it uses the wx-config utility. You can select between +# debug/release, unicode/ansi, universal/non-universal, and +# static/shared in the QtDialog or ccmake interfaces by turning ON/OFF +# the following variables: +# +# :: +# +# wxWidgets_USE_DEBUG +# wxWidgets_USE_UNICODE +# wxWidgets_USE_UNIVERSAL +# wxWidgets_USE_STATIC +# +# +# +# There is also a wxWidgets_CONFIG_OPTIONS variable for all other +# options that need to be passed to the wx-config utility. For example, +# to use the base toolkit found in the /usr/local path, set the variable +# (before calling the FIND_PACKAGE command) as such: +# +# :: +# +# set(wxWidgets_CONFIG_OPTIONS --toolkit=base --prefix=/usr) +# +# +# +# The following are set after the configuration is done for both windows +# and unix style: +# +# :: +# +# wxWidgets_FOUND - Set to TRUE if wxWidgets was found. +# wxWidgets_INCLUDE_DIRS - Include directories for WIN32 +# i.e., where to find "wx/wx.h" and +# "wx/setup.h"; possibly empty for unices. +# wxWidgets_LIBRARIES - Path to the wxWidgets libraries. +# wxWidgets_LIBRARY_DIRS - compile time link dirs, useful for +# rpath on UNIX. Typically an empty string +# in WIN32 environment. +# wxWidgets_DEFINITIONS - Contains defines required to compile/link +# against WX, e.g. WXUSINGDLL +# wxWidgets_DEFINITIONS_DEBUG- Contains defines required to compile/link +# against WX debug builds, e.g. __WXDEBUG__ +# wxWidgets_CXX_FLAGS - Include dirs and compiler flags for +# unices, empty on WIN32. Essentially +# "`wx-config --cxxflags`". +# wxWidgets_USE_FILE - Convenience include file. +# +# +# +# Sample usage: +# +# :: +# +# # Note that for MinGW users the order of libs is important! +# find_package(wxWidgets COMPONENTS net gl core base) +# if(wxWidgets_FOUND) +# include(${wxWidgets_USE_FILE}) +# # and for each of your dependent executable/library targets: +# target_link_libraries( ${wxWidgets_LIBRARIES}) +# endif() +# +# +# +# If wxWidgets is required (i.e., not an optional part): +# +# :: +# +# find_package(wxWidgets REQUIRED net gl core base) +# include(${wxWidgets_USE_FILE}) +# # and for each of your dependent executable/library targets: +# target_link_libraries( ${wxWidgets_LIBRARIES}) + +#============================================================================= +# Copyright 2004-2009 Kitware, Inc. +# Copyright 2007-2009 Miguel A. Figueroa-Villanueva +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file Copyright.txt for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= +# (To distribute this file outside of CMake, substitute the full +# License text for the above reference.) + +# +# FIXME: check this and provide a correct sample usage... +# Remember to connect back to the upper text. +# Sample usage with monolithic wx build: +# +# find_package(wxWidgets COMPONENTS mono) +# ... + +# NOTES +# +# This module has been tested on the WIN32 platform with wxWidgets +# 2.6.2, 2.6.3, and 2.5.3. However, it has been designed to +# easily extend support to all possible builds, e.g., static/shared, +# debug/release, unicode, universal, multilib/monolithic, etc.. +# +# If you want to use the module and your build type is not supported +# out-of-the-box, please contact me to exchange information on how +# your system is setup and I'll try to add support for it. +# +# AUTHOR +# +# Miguel A. Figueroa-Villanueva (miguelf at ieee dot org). +# Jan Woetzel (jw at mip.informatik.uni-kiel.de). +# +# Based on previous works of: +# Jan Woetzel (FindwxWindows.cmake), +# Jorgen Bodde and Jerry Fath (FindwxWin.cmake). + +# TODO/ideas +# +# (1) Option/Setting to use all available wx libs +# In contrast to expert developer who lists the +# minimal set of required libs in wxWidgets_USE_LIBS +# there is the newbie user: +# - who just wants to link against WX with more 'magic' +# - doesn't know the internal structure of WX or how it was built, +# in particular if it is monolithic or not +# - want to link against all available WX libs +# Basically, the intent here is to mimic what wx-config would do by +# default (i.e., `wx-config --libs`). +# +# Possible solution: +# Add a reserved keyword "std" that initializes to what wx-config +# would default to. If the user has not set the wxWidgets_USE_LIBS, +# default to "std" instead of "base core" as it is now. To implement +# "std" will basically boil down to a FOR_EACH lib-FOUND, but maybe +# checking whether a minimal set was found. + + +# FIXME: This and all the DBG_MSG calls should be removed after the +# module stabilizes. +# +# Helper macro to control the debugging output globally. There are +# two versions for controlling how verbose your output should be. +macro(DBG_MSG _MSG) +# message(STATUS +# "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}): ${_MSG}") +endmacro() +macro(DBG_MSG_V _MSG) +# message(STATUS +# "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}): ${_MSG}") +endmacro() + +# Clear return values in case the module is loaded more than once. +set(wxWidgets_FOUND FALSE) +set(wxWidgets_INCLUDE_DIRS "") +set(wxWidgets_LIBRARIES "") +set(wxWidgets_LIBRARY_DIRS "") +set(wxWidgets_CXX_FLAGS "") + +# Using SYSTEM with INCLUDE_DIRECTORIES in conjunction with wxWidgets on +# the Mac produces compiler errors. Set wxWidgets_INCLUDE_DIRS_NO_SYSTEM +# to prevent UsewxWidgets.cmake from using SYSTEM. +# +# See cmake mailing list discussions for more info: +# http://www.cmake.org/pipermail/cmake/2008-April/021115.html +# http://www.cmake.org/pipermail/cmake/2008-April/021146.html +# +if(APPLE OR CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD") + set(wxWidgets_INCLUDE_DIRS_NO_SYSTEM 1) +endif() + +# DEPRECATED: This is a patch to support the DEPRECATED use of +# wxWidgets_USE_LIBS. +# +# If wxWidgets_USE_LIBS is set: +# - if using , then override wxWidgets_USE_LIBS +# - else set wxWidgets_FIND_COMPONENTS to wxWidgets_USE_LIBS +if(wxWidgets_USE_LIBS AND NOT wxWidgets_FIND_COMPONENTS) + set(wxWidgets_FIND_COMPONENTS ${wxWidgets_USE_LIBS}) +endif() +DBG_MSG("wxWidgets_FIND_COMPONENTS : ${wxWidgets_FIND_COMPONENTS}") + +# Add the convenience use file if available. +# +# Get dir of this file which may reside in: +# - CMAKE_MAKE_ROOT/Modules on CMake installation +# - CMAKE_MODULE_PATH if user prefers his own specialized version +set(wxWidgets_USE_FILE "") +get_filename_component( + wxWidgets_CURRENT_LIST_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) +# Prefer an existing customized version, but the user might override +# the FindwxWidgets module and not the UsewxWidgets one. +if(EXISTS "${wxWidgets_CURRENT_LIST_DIR}/UsewxWidgets.cmake") + set(wxWidgets_USE_FILE + "${wxWidgets_CURRENT_LIST_DIR}/UsewxWidgets.cmake") +else() + set(wxWidgets_USE_FILE UsewxWidgets) +endif() + +#===================================================================== +# Determine whether unix or win32 paths should be used +#===================================================================== +if(WIN32 AND NOT CYGWIN AND NOT MSYS AND NOT CMAKE_CROSSCOMPILING) + set(wxWidgets_FIND_STYLE "win32") +else() + set(wxWidgets_FIND_STYLE "unix") +endif() + +#===================================================================== +# WIN32_FIND_STYLE +#===================================================================== +if(wxWidgets_FIND_STYLE STREQUAL "win32") + # Useful common wx libs needed by almost all components. + set(wxWidgets_COMMON_LIBRARIES png tiff jpeg zlib regex expat) + + # DEPRECATED: Use find_package(wxWidgets COMPONENTS mono) instead. + if(NOT wxWidgets_FIND_COMPONENTS) + if(wxWidgets_USE_MONOLITHIC) + set(wxWidgets_FIND_COMPONENTS mono) + else() + set(wxWidgets_FIND_COMPONENTS core base) # this is default + endif() + endif() + + # Add the common (usually required libs) unless + # wxWidgets_EXCLUDE_COMMON_LIBRARIES has been set. + if(NOT wxWidgets_EXCLUDE_COMMON_LIBRARIES) + list(APPEND wxWidgets_FIND_COMPONENTS + ${wxWidgets_COMMON_LIBRARIES}) + endif() + + #------------------------------------------------------------------- + # WIN32: Helper MACROS + #------------------------------------------------------------------- + # + # Get filename components for a configuration. For example, + # if _CONFIGURATION = mswunivud, then _UNV=univ, _UCD=u _DBG=d + # if _CONFIGURATION = mswu, then _UNV="", _UCD=u _DBG="" + # + macro(WX_GET_NAME_COMPONENTS _CONFIGURATION _UNV _UCD _DBG) + string(REGEX MATCH "univ" ${_UNV} "${_CONFIGURATION}") + string(REGEX REPLACE "msw.*(u)[d]*$" "u" ${_UCD} "${_CONFIGURATION}") + if(${_UCD} STREQUAL ${_CONFIGURATION}) + set(${_UCD} "") + endif() + string(REGEX MATCH "d$" ${_DBG} "${_CONFIGURATION}") + endmacro() + + # + # Find libraries associated to a configuration. + # + macro(WX_FIND_LIBS _UNV _UCD _DBG) + DBG_MSG_V("m_unv = ${_UNV}") + DBG_MSG_V("m_ucd = ${_UCD}") + DBG_MSG_V("m_dbg = ${_DBG}") + + # FIXME: What if both regex libs are available. regex should be + # found outside the loop and only wx${LIB}${_UCD}${_DBG}. + # Find wxWidgets common libraries. + foreach(LIB ${wxWidgets_COMMON_LIBRARIES} scintilla) + find_library(WX_${LIB}${_DBG} + NAMES + wx${LIB}${_UCD}${_DBG} # for regex + wx${LIB}${_DBG} + PATHS ${WX_LIB_DIR} + NO_DEFAULT_PATH + ) + mark_as_advanced(WX_${LIB}${_DBG}) + endforeach() + + # Find wxWidgets multilib base libraries. + find_library(WX_base${_DBG} + NAMES + wxbase30${_UCD}${_DBG} + wxbase29${_UCD}${_DBG} + wxbase28${_UCD}${_DBG} + wxbase27${_UCD}${_DBG} + wxbase26${_UCD}${_DBG} + wxbase25${_UCD}${_DBG} + PATHS ${WX_LIB_DIR} + NO_DEFAULT_PATH + ) + mark_as_advanced(WX_base${_DBG}) + foreach(LIB net odbc xml) + find_library(WX_${LIB}${_DBG} + NAMES + wxbase30${_UCD}${_DBG}_${LIB} + wxbase29${_UCD}${_DBG}_${LIB} + wxbase28${_UCD}${_DBG}_${LIB} + wxbase27${_UCD}${_DBG}_${LIB} + wxbase26${_UCD}${_DBG}_${LIB} + wxbase25${_UCD}${_DBG}_${LIB} + PATHS ${WX_LIB_DIR} + NO_DEFAULT_PATH + ) + mark_as_advanced(WX_${LIB}${_DBG}) + endforeach() + + # Find wxWidgets monolithic library. + find_library(WX_mono${_DBG} + NAMES + wxmsw${_UNV}30${_UCD}${_DBG} + wxmsw${_UNV}29${_UCD}${_DBG} + wxmsw${_UNV}28${_UCD}${_DBG} + wxmsw${_UNV}27${_UCD}${_DBG} + wxmsw${_UNV}26${_UCD}${_DBG} + wxmsw${_UNV}25${_UCD}${_DBG} + PATHS ${WX_LIB_DIR} + NO_DEFAULT_PATH + ) + mark_as_advanced(WX_mono${_DBG}) + + # Find wxWidgets multilib libraries. + foreach(LIB core adv aui html media xrc dbgrid gl qa richtext + stc ribbon propgrid webview) + find_library(WX_${LIB}${_DBG} + NAMES + wxmsw${_UNV}30${_UCD}${_DBG}_${LIB} + wxmsw${_UNV}29${_UCD}${_DBG}_${LIB} + wxmsw${_UNV}28${_UCD}${_DBG}_${LIB} + wxmsw${_UNV}27${_UCD}${_DBG}_${LIB} + wxmsw${_UNV}26${_UCD}${_DBG}_${LIB} + wxmsw${_UNV}25${_UCD}${_DBG}_${LIB} + PATHS ${WX_LIB_DIR} + NO_DEFAULT_PATH + ) + mark_as_advanced(WX_${LIB}${_DBG}) + endforeach() + endmacro() + + # + # Clear all library paths, so that FIND_LIBRARY refinds them. + # + # Clear a lib, reset its found flag, and mark as advanced. + macro(WX_CLEAR_LIB _LIB) + set(${_LIB} "${_LIB}-NOTFOUND" CACHE FILEPATH "Cleared." FORCE) + set(${_LIB}_FOUND FALSE) + mark_as_advanced(${_LIB}) + endmacro() + # Clear all debug or release library paths (arguments are "d" or ""). + macro(WX_CLEAR_ALL_LIBS _DBG) + # Clear wxWidgets common libraries. + foreach(LIB ${wxWidgets_COMMON_LIBRARIES} scintilla) + WX_CLEAR_LIB(WX_${LIB}${_DBG}) + endforeach() + + # Clear wxWidgets multilib base libraries. + WX_CLEAR_LIB(WX_base${_DBG}) + foreach(LIB net odbc xml) + WX_CLEAR_LIB(WX_${LIB}${_DBG}) + endforeach() + + # Clear wxWidgets monolithic library. + WX_CLEAR_LIB(WX_mono${_DBG}) + + # Clear wxWidgets multilib libraries. + foreach(LIB core adv aui html media xrc dbgrid gl qa richtext + stc ribbon propgrid) + WX_CLEAR_LIB(WX_${LIB}${_DBG}) + endforeach() + endmacro() + # Clear all wxWidgets debug libraries. + macro(WX_CLEAR_ALL_DBG_LIBS) + WX_CLEAR_ALL_LIBS("d") + endmacro() + # Clear all wxWidgets release libraries. + macro(WX_CLEAR_ALL_REL_LIBS) + WX_CLEAR_ALL_LIBS("") + endmacro() + + # + # Set the wxWidgets_LIBRARIES variable. + # Also, Sets output variable wxWidgets_FOUND to FALSE if it fails. + # + macro(WX_SET_LIBRARIES _LIBS _DBG) + DBG_MSG_V("Looking for ${${_LIBS}}") + if(WX_USE_REL_AND_DBG) + foreach(LIB ${${_LIBS}}) + DBG_MSG_V("Searching for ${LIB} and ${LIB}d") + DBG_MSG_V("WX_${LIB} : ${WX_${LIB}}") + DBG_MSG_V("WX_${LIB}d : ${WX_${LIB}d}") + if(WX_${LIB} AND WX_${LIB}d) + DBG_MSG_V("Found ${LIB} and ${LIB}d") + list(APPEND wxWidgets_LIBRARIES + debug ${WX_${LIB}d} optimized ${WX_${LIB}} + ) + else() + DBG_MSG_V("- not found due to missing WX_${LIB}=${WX_${LIB}} or WX_${LIB}d=${WX_${LIB}d}") + set(wxWidgets_FOUND FALSE) + endif() + endforeach() + else() + foreach(LIB ${${_LIBS}}) + DBG_MSG_V("Searching for ${LIB}${_DBG}") + DBG_MSG_V("WX_${LIB}${_DBG} : ${WX_${LIB}${_DBG}}") + if(WX_${LIB}${_DBG}) + DBG_MSG_V("Found ${LIB}${_DBG}") + list(APPEND wxWidgets_LIBRARIES ${WX_${LIB}${_DBG}}) + else() + DBG_MSG_V( + "- not found due to missing WX_${LIB}${_DBG}=${WX_${LIB}${_DBG}}") + set(wxWidgets_FOUND FALSE) + endif() + endforeach() + endif() + + DBG_MSG_V("OpenGL") + list(FIND ${_LIBS} gl WX_USE_GL) + if(NOT WX_USE_GL EQUAL -1) + DBG_MSG_V("- is required.") + list(APPEND wxWidgets_LIBRARIES opengl32 glu32) + endif() + + list(APPEND wxWidgets_LIBRARIES winmm comctl32 rpcrt4 wsock32) + endmacro() + + #------------------------------------------------------------------- + # WIN32: Start actual work. + #------------------------------------------------------------------- + + # Look for an installation tree. + find_path(wxWidgets_ROOT_DIR + NAMES include/wx/wx.h + PATHS + ENV wxWidgets_ROOT_DIR + ENV WXWIN + "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\wxWidgets_is1;Inno Setup: App Path]" # WX 2.6.x + C:/ + D:/ + ENV ProgramFiles + PATH_SUFFIXES + wxWidgets-3.0.0 + wxWidgets-2.9.5 + wxWidgets-2.9.4 + wxWidgets-2.9.3 + wxWidgets-2.9.2 + wxWidgets-2.9.1 + wxWidgets-2.9.0 + wxWidgets-2.8.9 + wxWidgets-2.8.8 + wxWidgets-2.8.7 + wxWidgets-2.8.6 + wxWidgets-2.8.5 + wxWidgets-2.8.4 + wxWidgets-2.8.3 + wxWidgets-2.8.2 + wxWidgets-2.8.1 + wxWidgets-2.8.0 + wxWidgets-2.7.4 + wxWidgets-2.7.3 + wxWidgets-2.7.2 + wxWidgets-2.7.1 + wxWidgets-2.7.0 + wxWidgets-2.7.0-1 + wxWidgets-2.6.4 + wxWidgets-2.6.3 + wxWidgets-2.6.2 + wxWidgets-2.6.1 + wxWidgets-2.5.4 + wxWidgets-2.5.3 + wxWidgets-2.5.2 + wxWidgets-2.5.1 + wxWidgets + DOC "wxWidgets base/installation directory" + ) + + # If wxWidgets_ROOT_DIR changed, clear lib dir. + if(NOT WX_ROOT_DIR STREQUAL wxWidgets_ROOT_DIR) + set(WX_ROOT_DIR ${wxWidgets_ROOT_DIR} + CACHE INTERNAL "wxWidgets_ROOT_DIR") + set(wxWidgets_LIB_DIR "wxWidgets_LIB_DIR-NOTFOUND" + CACHE PATH "Cleared." FORCE) + endif() + + if(WX_ROOT_DIR) + # Select one default tree inside the already determined wx tree. + # Prefer static/shared order usually consistent with build + # settings. + if(MINGW) + set(WX_LIB_DIR_PREFIX gcc) + elseif(CMAKE_CL_64) + set(WX_LIB_DIR_PREFIX vc_x64) + else() + set(WX_LIB_DIR_PREFIX vc) + endif() + if(BUILD_SHARED_LIBS) + find_path(wxWidgets_LIB_DIR + NAMES + msw/wx/setup.h + mswd/wx/setup.h + mswu/wx/setup.h + mswud/wx/setup.h + mswuniv/wx/setup.h + mswunivd/wx/setup.h + mswunivu/wx/setup.h + mswunivud/wx/setup.h + PATHS + ${WX_ROOT_DIR}/lib/${WX_LIB_DIR_PREFIX}_dll # prefer shared + ${WX_ROOT_DIR}/lib/${WX_LIB_DIR_PREFIX}_lib + DOC "Path to wxWidgets libraries" + NO_DEFAULT_PATH + ) + else() + find_path(wxWidgets_LIB_DIR + NAMES + msw/wx/setup.h + mswd/wx/setup.h + mswu/wx/setup.h + mswud/wx/setup.h + mswuniv/wx/setup.h + mswunivd/wx/setup.h + mswunivu/wx/setup.h + mswunivud/wx/setup.h + PATHS + ${WX_ROOT_DIR}/lib/${WX_LIB_DIR_PREFIX}_lib # prefer static + ${WX_ROOT_DIR}/lib/${WX_LIB_DIR_PREFIX}_dll + DOC "Path to wxWidgets libraries" + NO_DEFAULT_PATH + ) + endif() + + # If wxWidgets_LIB_DIR changed, clear all libraries. + if(NOT WX_LIB_DIR STREQUAL wxWidgets_LIB_DIR) + set(WX_LIB_DIR ${wxWidgets_LIB_DIR} CACHE INTERNAL "wxWidgets_LIB_DIR") + WX_CLEAR_ALL_DBG_LIBS() + WX_CLEAR_ALL_REL_LIBS() + endif() + + if(WX_LIB_DIR) + # If building shared libs, define WXUSINGDLL to use dllimport. + if(WX_LIB_DIR MATCHES "[dD][lL][lL]") + set(wxWidgets_DEFINITIONS WXUSINGDLL) + DBG_MSG_V("detected SHARED/DLL tree WX_LIB_DIR=${WX_LIB_DIR}") + endif() + + # Search for available configuration types. + foreach(CFG mswunivud mswunivd mswud mswd mswunivu mswuniv mswu msw) + set(WX_${CFG}_FOUND FALSE) + if(EXISTS ${WX_LIB_DIR}/${CFG}) + list(APPEND WX_CONFIGURATION_LIST ${CFG}) + set(WX_${CFG}_FOUND TRUE) + set(WX_CONFIGURATION ${CFG}) + endif() + endforeach() + DBG_MSG_V("WX_CONFIGURATION_LIST=${WX_CONFIGURATION_LIST}") + + if(WX_CONFIGURATION) + set(wxWidgets_FOUND TRUE) + + # If the selected configuration wasn't found force the default + # one. Otherwise, use it but still force a refresh for + # updating the doc string with the current list of available + # configurations. + if(NOT WX_${wxWidgets_CONFIGURATION}_FOUND) + set(wxWidgets_CONFIGURATION ${WX_CONFIGURATION} CACHE STRING + "Set wxWidgets configuration (${WX_CONFIGURATION_LIST})" FORCE) + else() + set(wxWidgets_CONFIGURATION ${wxWidgets_CONFIGURATION} CACHE STRING + "Set wxWidgets configuration (${WX_CONFIGURATION_LIST})" FORCE) + endif() + + # If release config selected, and both release/debug exist. + if(WX_${wxWidgets_CONFIGURATION}d_FOUND) + option(wxWidgets_USE_REL_AND_DBG + "Use release and debug configurations?" TRUE) + set(WX_USE_REL_AND_DBG ${wxWidgets_USE_REL_AND_DBG}) + else() + # If the option exists (already in cache), force it false. + if(wxWidgets_USE_REL_AND_DBG) + set(wxWidgets_USE_REL_AND_DBG FALSE CACHE BOOL + "No ${wxWidgets_CONFIGURATION}d found." FORCE) + endif() + set(WX_USE_REL_AND_DBG FALSE) + endif() + + # Get configuration parameters from the name. + WX_GET_NAME_COMPONENTS(${wxWidgets_CONFIGURATION} UNV UCD DBG) + + # Set wxWidgets lib setup include directory. + if(EXISTS ${WX_LIB_DIR}/${wxWidgets_CONFIGURATION}/wx/setup.h) + set(wxWidgets_INCLUDE_DIRS + ${WX_LIB_DIR}/${wxWidgets_CONFIGURATION}) + else() + DBG_MSG("wxWidgets_FOUND FALSE because ${WX_LIB_DIR}/${wxWidgets_CONFIGURATION}/wx/setup.h does not exists.") + set(wxWidgets_FOUND FALSE) + endif() + + # Set wxWidgets main include directory. + if(EXISTS ${WX_ROOT_DIR}/include/wx/wx.h) + list(APPEND wxWidgets_INCLUDE_DIRS ${WX_ROOT_DIR}/include) + else() + DBG_MSG("wxWidgets_FOUND FALSE because WX_ROOT_DIR=${WX_ROOT_DIR} has no ${WX_ROOT_DIR}/include/wx/wx.h") + set(wxWidgets_FOUND FALSE) + endif() + + # Find wxWidgets libraries. + WX_FIND_LIBS("${UNV}" "${UCD}" "${DBG}") + if(WX_USE_REL_AND_DBG) + WX_FIND_LIBS("${UNV}" "${UCD}" "d") + endif() + + # Settings for requested libs (i.e., include dir, libraries, etc.). + WX_SET_LIBRARIES(wxWidgets_FIND_COMPONENTS "${DBG}") + + # Add necessary definitions for unicode builds + if("${UCD}" STREQUAL "u") + list(APPEND wxWidgets_DEFINITIONS UNICODE _UNICODE) + endif() + + # Add necessary definitions for debug builds + set(wxWidgets_DEFINITIONS_DEBUG _DEBUG __WXDEBUG__) + + endif() + endif() + endif() + +#===================================================================== +# UNIX_FIND_STYLE +#===================================================================== +else() + if(wxWidgets_FIND_STYLE STREQUAL "unix") + #----------------------------------------------------------------- + # UNIX: Helper MACROS + #----------------------------------------------------------------- + # + # Set the default values based on "wx-config --selected-config". + # + macro(WX_CONFIG_SELECT_GET_DEFAULT) + execute_process( + COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}" + ${wxWidgets_CONFIG_OPTIONS} --selected-config + OUTPUT_VARIABLE _wx_selected_config + RESULT_VARIABLE _wx_result + ERROR_QUIET + ) + if(_wx_result EQUAL 0) + foreach(_opt_name debug static unicode universal) + string(TOUPPER ${_opt_name} _upper_opt_name) + if(_wx_selected_config MATCHES "${_opt_name}") + set(wxWidgets_DEFAULT_${_upper_opt_name} ON) + else() + set(wxWidgets_DEFAULT_${_upper_opt_name} OFF) + endif() + endforeach() + else() + foreach(_upper_opt_name DEBUG STATIC UNICODE UNIVERSAL) + set(wxWidgets_DEFAULT_${_upper_opt_name} OFF) + endforeach() + endif() + endmacro() + + # + # Query a boolean configuration option to determine if the system + # has both builds available. If so, provide the selection option + # to the user. + # + macro(WX_CONFIG_SELECT_QUERY_BOOL _OPT_NAME _OPT_HELP) + execute_process( + COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}" + ${wxWidgets_CONFIG_OPTIONS} --${_OPT_NAME}=yes + RESULT_VARIABLE _wx_result_yes + OUTPUT_QUIET + ERROR_QUIET + ) + execute_process( + COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}" + ${wxWidgets_CONFIG_OPTIONS} --${_OPT_NAME}=no + RESULT_VARIABLE _wx_result_no + OUTPUT_QUIET + ERROR_QUIET + ) + string(TOUPPER ${_OPT_NAME} _UPPER_OPT_NAME) + if(_wx_result_yes EQUAL 0 AND _wx_result_no EQUAL 0) + option(wxWidgets_USE_${_UPPER_OPT_NAME} + ${_OPT_HELP} ${wxWidgets_DEFAULT_${_UPPER_OPT_NAME}}) + else() + # If option exists (already in cache), force to available one. + if(DEFINED wxWidgets_USE_${_UPPER_OPT_NAME}) + if(_wx_result_yes EQUAL 0) + set(wxWidgets_USE_${_UPPER_OPT_NAME} ON CACHE BOOL ${_OPT_HELP} FORCE) + else() + set(wxWidgets_USE_${_UPPER_OPT_NAME} OFF CACHE BOOL ${_OPT_HELP} FORCE) + endif() + endif() + endif() + endmacro() + + # + # Set wxWidgets_SELECT_OPTIONS to wx-config options for selecting + # among multiple builds. + # + macro(WX_CONFIG_SELECT_SET_OPTIONS) + set(wxWidgets_SELECT_OPTIONS ${wxWidgets_CONFIG_OPTIONS}) + foreach(_opt_name debug static unicode universal) + string(TOUPPER ${_opt_name} _upper_opt_name) + if(DEFINED wxWidgets_USE_${_upper_opt_name}) + if(wxWidgets_USE_${_upper_opt_name}) + list(APPEND wxWidgets_SELECT_OPTIONS --${_opt_name}=yes) + else() + list(APPEND wxWidgets_SELECT_OPTIONS --${_opt_name}=no) + endif() + endif() + endforeach() + endmacro() + + #----------------------------------------------------------------- + # UNIX: Start actual work. + #----------------------------------------------------------------- + # Support cross-compiling, only search in the target platform. + find_program(wxWidgets_CONFIG_EXECUTABLE wx-config + DOC "Location of wxWidgets library configuration provider binary (wx-config)." + ONLY_CMAKE_FIND_ROOT_PATH + ) + + if(wxWidgets_CONFIG_EXECUTABLE) + set(wxWidgets_FOUND TRUE) + + # get defaults based on "wx-config --selected-config" + WX_CONFIG_SELECT_GET_DEFAULT() + + # for each option: if both builds are available, provide option + WX_CONFIG_SELECT_QUERY_BOOL(debug "Use debug build?") + WX_CONFIG_SELECT_QUERY_BOOL(unicode "Use unicode build?") + WX_CONFIG_SELECT_QUERY_BOOL(universal "Use universal build?") + WX_CONFIG_SELECT_QUERY_BOOL(static "Link libraries statically?") + + # process selection to set wxWidgets_SELECT_OPTIONS + WX_CONFIG_SELECT_SET_OPTIONS() + DBG_MSG("wxWidgets_SELECT_OPTIONS=${wxWidgets_SELECT_OPTIONS}") + + # run the wx-config program to get cxxflags + execute_process( + COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}" + ${wxWidgets_SELECT_OPTIONS} --cxxflags + OUTPUT_VARIABLE wxWidgets_CXX_FLAGS + RESULT_VARIABLE RET + ERROR_QUIET + ) + if(RET EQUAL 0) + string(STRIP "${wxWidgets_CXX_FLAGS}" wxWidgets_CXX_FLAGS) + separate_arguments(wxWidgets_CXX_FLAGS) + + DBG_MSG_V("wxWidgets_CXX_FLAGS=${wxWidgets_CXX_FLAGS}") + + # parse definitions from cxxflags; + # drop -D* from CXXFLAGS and the -D prefix + string(REGEX MATCHALL "-D[^;]+" + wxWidgets_DEFINITIONS "${wxWidgets_CXX_FLAGS}") + string(REGEX REPLACE "-D[^;]+(;|$)" "" + wxWidgets_CXX_FLAGS "${wxWidgets_CXX_FLAGS}") + string(REGEX REPLACE ";$" "" + wxWidgets_CXX_FLAGS "${wxWidgets_CXX_FLAGS}") + string(REPLACE "-D" "" + wxWidgets_DEFINITIONS "${wxWidgets_DEFINITIONS}") + + # parse include dirs from cxxflags; drop -I prefix + string(REGEX MATCHALL "-I[^;]+" + wxWidgets_INCLUDE_DIRS "${wxWidgets_CXX_FLAGS}") + string(REGEX REPLACE "-I[^;]+;" "" + wxWidgets_CXX_FLAGS "${wxWidgets_CXX_FLAGS}") + string(REPLACE "-I" "" + wxWidgets_INCLUDE_DIRS "${wxWidgets_INCLUDE_DIRS}") + + DBG_MSG_V("wxWidgets_DEFINITIONS=${wxWidgets_DEFINITIONS}") + DBG_MSG_V("wxWidgets_INCLUDE_DIRS=${wxWidgets_INCLUDE_DIRS}") + DBG_MSG_V("wxWidgets_CXX_FLAGS=${wxWidgets_CXX_FLAGS}") + + else() + set(wxWidgets_FOUND FALSE) + DBG_MSG_V( + "${wxWidgets_CONFIG_EXECUTABLE} --cxxflags FAILED with RET=${RET}") + endif() + + # run the wx-config program to get the libs + # - NOTE: wx-config doesn't verify that the libs requested exist + # it just produces the names. Maybe a TRY_COMPILE would + # be useful here... + string(REPLACE ";" "," + wxWidgets_FIND_COMPONENTS "${wxWidgets_FIND_COMPONENTS}") + execute_process( + COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}" + ${wxWidgets_SELECT_OPTIONS} --libs ${wxWidgets_FIND_COMPONENTS} + OUTPUT_VARIABLE wxWidgets_LIBRARIES + RESULT_VARIABLE RET + ERROR_QUIET + ) + if(RET EQUAL 0) + string(STRIP "${wxWidgets_LIBRARIES}" wxWidgets_LIBRARIES) + separate_arguments(wxWidgets_LIBRARIES) + string(REPLACE "-framework;" "-framework " + wxWidgets_LIBRARIES "${wxWidgets_LIBRARIES}") + string(REPLACE "-arch;" "-arch " + wxWidgets_LIBRARIES "${wxWidgets_LIBRARIES}") + string(REPLACE "-isysroot;" "-isysroot " + wxWidgets_LIBRARIES "${wxWidgets_LIBRARIES}") + + # extract linkdirs (-L) for rpath (i.e., LINK_DIRECTORIES) + string(REGEX MATCHALL "-L[^;]+" + wxWidgets_LIBRARY_DIRS "${wxWidgets_LIBRARIES}") + string(REPLACE "-L" "" + wxWidgets_LIBRARY_DIRS "${wxWidgets_LIBRARY_DIRS}") + + DBG_MSG_V("wxWidgets_LIBRARIES=${wxWidgets_LIBRARIES}") + DBG_MSG_V("wxWidgets_LIBRARY_DIRS=${wxWidgets_LIBRARY_DIRS}") + + else() + set(wxWidgets_FOUND FALSE) + DBG_MSG("${wxWidgets_CONFIG_EXECUTABLE} --libs ${wxWidgets_FIND_COMPONENTS} FAILED with RET=${RET}") + endif() + endif() + +#===================================================================== +# Neither UNIX_FIND_STYLE, nor WIN32_FIND_STYLE +#===================================================================== + else() + if(NOT wxWidgets_FIND_QUIETLY) + message(STATUS + "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}): \n" + " Platform unknown/unsupported. It's neither WIN32 nor UNIX " + "find style." + ) + endif() + endif() +endif() + +SET(wxWidgets_LIBRARIES_GUI ${wxWidgets_LIBRARIES}) +STRING(REPLACE "-Wl,--subsystem,windows" "-Wl,--subsystem,console" wxWidgets_LIBRARIES_CONSOLE "${wxWidgets_LIBRARIES}") +STRING(REPLACE "-mwindows" "-mconsole" wxWidgets_LIBRARIES_CONSOLE "${wxWidgets_LIBRARIES_CONSOLE}") + +# Debug output: +DBG_MSG("wxWidgets_FOUND : ${wxWidgets_FOUND}") +DBG_MSG("wxWidgets_INCLUDE_DIRS : ${wxWidgets_INCLUDE_DIRS}") +DBG_MSG("wxWidgets_LIBRARY_DIRS : ${wxWidgets_LIBRARY_DIRS}") +DBG_MSG("wxWidgets_LIBRARIES : ${wxWidgets_LIBRARIES}") +DBG_MSG("wxWidgets_CXX_FLAGS : ${wxWidgets_CXX_FLAGS}") +DBG_MSG("wxWidgets_USE_FILE : ${wxWidgets_USE_FILE}") + +#===================================================================== +#===================================================================== +include(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(wxWidgets DEFAULT_MSG wxWidgets_FOUND) +# Maintain consistency with all other variables. +set(wxWidgets_FOUND ${WXWIDGETS_FOUND}) + +#===================================================================== +# Macros for use in wxWidgets apps. +# - This module will not fail to find wxWidgets based on the code +# below. Hence, it's required to check for validity of: +# +# wxWidgets_wxrc_EXECUTABLE +#===================================================================== + +# Resource file compiler. +find_program(wxWidgets_wxrc_EXECUTABLE wxrc + ${wxWidgets_ROOT_DIR}/utils/wxrc/vc_msw + DOC "Location of wxWidgets resource file compiler binary (wxrc)" + ) + +# +# WX_SPLIT_ARGUMENTS_ON( ...) +# +# Sets and to contain arguments to the left and right, +# respectively, of . +# +# Example usage: +# function(WXWIDGETS_ADD_RESOURCES outfiles) +# WX_SPLIT_ARGUMENTS_ON(OPTIONS wxrc_files wxrc_options ${ARGN}) +# ... +# endfunction() +# +# WXWIDGETS_ADD_RESOURCES(sources ${xrc_files} OPTIONS -e -o file.C) +# +# NOTE: This is a generic piece of code that should be renamed to +# SPLIT_ARGUMENTS_ON and put in a file serving the same purpose as +# FindPackageStandardArgs.cmake. At the time of this writing +# FindQt4.cmake has a QT4_EXTRACT_OPTIONS, which I basically copied +# here a bit more generalized. So, there are already two find modules +# using this approach. +# +function(WX_SPLIT_ARGUMENTS_ON _keyword _leftvar _rightvar) + # FIXME: Document that the input variables will be cleared. + #list(APPEND ${_leftvar} "") + #list(APPEND ${_rightvar} "") + set(${_leftvar} "") + set(${_rightvar} "") + + set(_doing_right FALSE) + foreach(element ${ARGN}) + if("${element}" STREQUAL "${_keyword}") + set(_doing_right TRUE) + else() + if(_doing_right) + list(APPEND ${_rightvar} "${element}") + else() + list(APPEND ${_leftvar} "${element}") + endif() + endif() + endforeach() + + set(${_leftvar} ${${_leftvar}} PARENT_SCOPE) + set(${_rightvar} ${${_rightvar}} PARENT_SCOPE) +endfunction() + +# +# WX_GET_DEPENDENCIES_FROM_XML( +# +# +# +# +# +# ) +# +# FIXME: Add documentation here... +# +function(WX_GET_DEPENDENCIES_FROM_XML + _depends + _match_patt + _clean_patt + _xml_contents + _depends_path + ) + + string(REGEX MATCHALL + ${_match_patt} + dep_file_list + "${${_xml_contents}}" + ) + foreach(dep_file ${dep_file_list}) + string(REGEX REPLACE ${_clean_patt} "" dep_file "${dep_file}") + + # make the file have an absolute path + if(NOT IS_ABSOLUTE "${dep_file}") + set(dep_file "${${_depends_path}}/${dep_file}") + endif() + + # append file to dependency list + list(APPEND ${_depends} "${dep_file}") + endforeach() + + set(${_depends} ${${_depends}} PARENT_SCOPE) +endfunction() + +# +# WXWIDGETS_ADD_RESOURCES( +# OPTIONS [NO_CPP_CODE]) +# +# Adds a custom command for resource file compilation of the +# and appends the output files to . +# +# Example usages: +# WXWIDGETS_ADD_RESOURCES(sources xrc/main_frame.xrc) +# WXWIDGETS_ADD_RESOURCES(sources ${xrc_files} OPTIONS -e -o altname.cxx) +# +function(WXWIDGETS_ADD_RESOURCES _outfiles) + WX_SPLIT_ARGUMENTS_ON(OPTIONS rc_file_list rc_options ${ARGN}) + + # Parse files for dependencies. + set(rc_file_list_abs "") + set(rc_depends "") + foreach(rc_file ${rc_file_list}) + get_filename_component(depends_path ${rc_file} PATH) + + get_filename_component(rc_file_abs ${rc_file} ABSOLUTE) + list(APPEND rc_file_list_abs "${rc_file_abs}") + + # All files have absolute paths or paths relative to the location + # of the rc file. + file(READ "${rc_file_abs}" rc_file_contents) + + # get bitmap/bitmap2 files + WX_GET_DEPENDENCIES_FROM_XML( + rc_depends + "]*>" + rc_file_contents + depends_path + ) + + # get url files + WX_GET_DEPENDENCIES_FROM_XML( + rc_depends + "]*>" + rc_file_contents + depends_path + ) + + # get wxIcon files + WX_GET_DEPENDENCIES_FROM_XML( + rc_depends + "]*class=\"wxIcon\"[^<]+" + "^]*>" + rc_file_contents + depends_path + ) + endforeach() + + # + # Parse options. + # + # If NO_CPP_CODE option specified, then produce .xrs file rather + # than a .cpp file (i.e., don't add the default --cpp-code option). + list(FIND rc_options NO_CPP_CODE index) + if(index EQUAL -1) + list(APPEND rc_options --cpp-code) + # wxrc's default output filename for cpp code. + set(outfile resource.cpp) + else() + list(REMOVE_AT rc_options ${index}) + # wxrc's default output filename for xrs file. + set(outfile resource.xrs) + endif() + + # Get output name for use in ADD_CUSTOM_COMMAND. + # - short option scanning + list(FIND rc_options -o index) + if(NOT index EQUAL -1) + math(EXPR filename_index "${index} + 1") + list(GET rc_options ${filename_index} outfile) + #list(REMOVE_AT rc_options ${index} ${filename_index}) + endif() + # - long option scanning + string(REGEX MATCH "--output=[^;]*" outfile_opt "${rc_options}") + if(outfile_opt) + string(REPLACE "--output=" "" outfile "${outfile_opt}") + endif() + #string(REGEX REPLACE "--output=[^;]*;?" "" rc_options "${rc_options}") + #string(REGEX REPLACE ";$" "" rc_options "${rc_options}") + + if(NOT IS_ABSOLUTE "${outfile}") + set(outfile "${CMAKE_CURRENT_BINARY_DIR}/${outfile}") + endif() + add_custom_command( + OUTPUT "${outfile}" + COMMAND ${wxWidgets_wxrc_EXECUTABLE} ${rc_options} ${rc_file_list_abs} + DEPENDS ${rc_file_list_abs} ${rc_depends} + ) + + # Add generated header to output file list. + list(FIND rc_options -e short_index) + list(FIND rc_options --extra-cpp-code long_index) + if(NOT short_index EQUAL -1 OR NOT long_index EQUAL -1) + get_filename_component(outfile_ext ${outfile} EXT) + string(REPLACE "${outfile_ext}" ".h" outfile_header "${outfile}") + list(APPEND ${_outfiles} "${outfile_header}") + set_source_files_properties( + "${outfile_header}" PROPERTIES GENERATED TRUE + ) + endif() + + # Add generated file to output file list. + list(APPEND ${_outfiles} "${outfile}") + + set(${_outfiles} ${${_outfiles}} PARENT_SCOPE) +endfunction() diff --git a/config/LibFindMacros.cmake b/config/LibFindMacros.cmake new file mode 100644 index 0000000..49899a8 --- /dev/null +++ b/config/LibFindMacros.cmake @@ -0,0 +1,101 @@ +# Works the same as find_package, but forwards the "REQUIRED" and "QUIET" arguments +# used for the current package. For this to work, the first parameter must be the +# prefix of the current package, then the prefix of the new package etc, which are +# passed to find_package. +macro (libfind_package PREFIX) + set (LIBFIND_PACKAGE_ARGS ${ARGN}) + if (${PREFIX}_FIND_QUIETLY) + set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET) + endif (${PREFIX}_FIND_QUIETLY) + if (${PREFIX}_FIND_REQUIRED) + set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED) + endif (${PREFIX}_FIND_REQUIRED) + find_package(${LIBFIND_PACKAGE_ARGS}) +endmacro (libfind_package) + +# CMake developers made the UsePkgConfig system deprecated in the same release (2.6) +# where they added pkg_check_modules. Consequently I need to support both in my scripts +# to avoid those deprecated warnings. Here's a helper that does just that. +# Works identically to pkg_check_modules, except that no checks are needed prior to use. +macro (libfind_pkg_check_modules PREFIX PKGNAME) + if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4) + include(UsePkgConfig) + pkgconfig(${PKGNAME} ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARY_DIRS ${PREFIX}_LDFLAGS ${PREFIX}_CFLAGS) + else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4) + find_package(PkgConfig) + if (PKG_CONFIG_FOUND) + pkg_check_modules(${PREFIX} ${PKGNAME}) + endif (PKG_CONFIG_FOUND) + endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4) +endmacro (libfind_pkg_check_modules) + +# Do the final processing once the paths have been detected. +# If include dirs are needed, ${PREFIX}_PROCESS_INCLUDES should be set to contain +# all the variables, each of which contain one include directory. +# Ditto for ${PREFIX}_PROCESS_LIBS and library files. +# Will set ${PREFIX}_FOUND, ${PREFIX}_INCLUDE_DIRS and ${PREFIX}_LIBRARIES. +# Also handles errors in case library detection was required, etc. +macro (libfind_process PREFIX) + # Skip processing if already processed during this run + if (NOT ${PREFIX}_FOUND) + # Start with the assumption that the library was found + set (${PREFIX}_FOUND TRUE) + + # Process all includes and set _FOUND to false if any are missing + foreach (i ${${PREFIX}_PROCESS_INCLUDES}) + if (${i}) + set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}}) + mark_as_advanced(${i}) + else (${i}) + message(STATUS "Missing ${i}") + set (${PREFIX}_FOUND FALSE) + endif (${i}) + endforeach (i) + + # Process all libraries and set _FOUND to false if any are missing + foreach (i ${${PREFIX}_PROCESS_LIBS}) + if (${i}) + set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}}) + mark_as_advanced(${i}) + else (${i}) + message(STATUS "Missing ${i}") + set (${PREFIX}_FOUND FALSE) + endif (${i}) + endforeach (i) + + # Print message and/or exit on fatal error + if (${PREFIX}_FOUND) + if (NOT ${PREFIX}_FIND_QUIETLY) + message (STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}") + endif (NOT ${PREFIX}_FIND_QUIETLY) + else (${PREFIX}_FOUND) + if (${PREFIX}_FIND_REQUIRED) + foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS}) + message("${i}=${${i}}") + endforeach (i) + message (FATAL_ERROR "Required library ${PREFIX} NOT FOUND.\nInstall the library (dev version) and try again. If the library is already installed, use ccmake to set the missing variables manually.") + endif (${PREFIX}_FIND_REQUIRED) + endif (${PREFIX}_FOUND) + endif (NOT ${PREFIX}_FOUND) +endmacro (libfind_process) + +macro(libfind_library PREFIX basename) + set(TMP "") + if(MSVC80) + set(TMP -vc80) + endif(MSVC80) + if(MSVC90) + set(TMP -vc90) + endif(MSVC90) + set(${PREFIX}_LIBNAMES ${basename}${TMP}) + if(${ARGC} GREATER 2) + set(${PREFIX}_LIBNAMES ${basename}${TMP}-${ARGV2}) + string(REGEX REPLACE "\\." "_" TMP ${${PREFIX}_LIBNAMES}) + set(${PREFIX}_LIBNAMES ${${PREFIX}_LIBNAMES} ${TMP}) + endif(${ARGC} GREATER 2) + find_library(${PREFIX}_LIBRARY + NAMES ${${PREFIX}_LIBNAMES} + PATHS ${${PREFIX}_PKGCONF_LIBRARY_DIRS} + ) +endmacro(libfind_library) + diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 0000000..fc8552a --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,20 @@ +# This file is part of EPOCH. +# File: CMakeLists.txt +# Author: Florent Teichteil-Königsbuch +# Contact: florent.teichteil@onera.fr +# +# EPOCH 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. +# +# EPOCH 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 EPOCH. If not, see . + +CONFIGURE_FILE (${CMAKE_SOURCE_DIR}/doc/Doxyfile.cmake ${CMAKE_BINARY_DIR}/doc/Doxyfile @ONLY) +ADD_CUSTOM_TARGET (html ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/doc/Doxyfile) diff --git a/doc/Doxyfile.cmake b/doc/Doxyfile.cmake new file mode 100644 index 0000000..37be3b6 --- /dev/null +++ b/doc/Doxyfile.cmake @@ -0,0 +1,1663 @@ +# Doxyfile 1.7.1 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# http://www.gnu.org/software/libiconv for the list of possible encodings. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = EPOCH + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = 9999 + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = @CMAKE_BINARY_DIR@/doc + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, +# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, +# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English +# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, +# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, +# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = @CMAKE_BINARY_DIR@/doc/ + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like regular Qt-style comments +# (thus requiring an explicit @brief command for a brief description.) + +JAVADOC_AUTOBRIEF = NO + +# If the QT_AUTOBRIEF tag is set to YES then Doxygen will +# interpret the first line (until the first dot) of a Qt-style +# comment as the brief description. If set to NO, the comments +# will behave just like regular Qt-style comments (thus requiring +# an explicit \brief command for a brief description.) + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for +# Java. For instance, namespaces will be presented as packages, qualified +# scopes will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources only. Doxygen will then generate output that is more tailored for +# Fortran. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for +# VHDL. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given extension. +# Doxygen has a built-in mapping, but you can override or extend it using this +# tag. The format is ext=language, where ext is a file extension, and language +# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C, +# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make +# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C +# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions +# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = YES + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. +# Doxygen will parse them like normal C++ but will assume all classes use public +# instead of private inheritance when no explicit protection keyword is present. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate getter +# and setter methods for a property. Setting this option to YES (the default) +# will make doxygen to replace the get and set methods by a property in the +# documentation. This will only work if the methods are indeed getting or +# setting a simple type. If this is not the case, or you want to show the +# methods anyway, you should set this option to NO. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum +# is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically +# be useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. + +TYPEDEF_HIDES_STRUCT = NO + +# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to +# determine which symbols to keep in memory and which to flush to disk. +# When the cache is full, less often used symbols will be written to disk. +# For small to medium size projects (<1000 input files) the default value is +# probably good enough. For larger projects a too small cache size can cause +# doxygen to be busy swapping symbols to and from disk most of the time +# causing a significant performance penality. +# If the system has enough physical memory increasing the cache will improve the +# performance by keeping more symbols in memory. Note that the value works on +# a logarithmic scale so increasing the size by one will rougly double the +# memory usage. The cache size is given by this formula: +# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, +# corresponding to a cache size of 2^16 = 65536 symbols + +SYMBOL_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = YES + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base +# name of the file that contains the anonymous namespace. By default +# anonymous namespace are hidden. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen +# will list include files with double quotes in the documentation +# rather than with sharp brackets. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen +# will sort the (brief and detailed) documentation of class members so that +# constructors and destructors are listed first. If set to NO (the default) +# the constructors will appear in the respective orders defined by +# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. +# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO +# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the +# hierarchy of group names into alphabetical order. If set to NO (the default) +# the group names will appear in their defined order. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. +# This will remove the Files entry from the Quick Index and from the +# Folder Tree View (if specified). The default is YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the +# Namespaces page. This will remove the Namespaces entry from the Quick Index +# and from the Folder Tree View (if specified). The default is YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. The create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. +# You can optionally specify a file name after the option, if omitted +# DoxygenLayout.xml will be used as the name of the layout file. + +LAYOUT_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = @CMAKE_SOURCE_DIR@ + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is +# also the default input encoding. Doxygen uses libiconv (or the iconv built +# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for +# the list of possible encodings. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 + +FILE_PATTERNS = *.c \ + *.cc \ + *.cxx \ + *.cpp \ + *.c++ \ + *.d \ + *.java \ + *.ii \ + *.ixx \ + *.ipp \ + *.i++ \ + *.inl \ + *.h \ + *.hh \ + *.hxx \ + *.hpp \ + *.h++ \ + *.idl \ + *.odl \ + *.cs \ + *.php \ + *.php3 \ + *.inc \ + *.m \ + *.mm \ + *.dox \ + *.py \ + *.f90 \ + *.f \ + *.vhd \ + *.vhdl \ + *.ipp \ + *.tpp + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) +# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from +# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will +# link to the source code. Otherwise they will link to the documentation. + +REFERENCES_LINK_SOURCE = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. +# Doxygen will adjust the colors in the stylesheet and background images +# according to this color. Hue is specified as an angle on a colorwheel, +# see http://en.wikipedia.org/wiki/Hue for more information. +# For instance the value 0 represents red, 60 is yellow, 120 is green, +# 180 is cyan, 240 is blue, 300 purple, and 360 is red again. +# The allowed range is 0 to 359. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of +# the colors in the HTML output. For a value of 0 the output will use +# grayscales only. A value of 255 will produce the most vivid colors. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to +# the luminance component of the colors in the HTML output. Values below +# 100 gradually make the output lighter, whereas values above 100 make +# the output darker. The value divided by 100 is the actual gamma applied, +# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, +# and 100 does not change the gamma. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting +# this to NO can help when comparing the output of multiple runs. + +HTML_TIMESTAMP = YES + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. For this to work a browser that supports +# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox +# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). + +HTML_DYNAMIC_SECTIONS = YES + +# If the GENERATE_DOCSET tag is set to YES, additional index files +# will be generated that can be used as input for Apple's Xcode 3 +# integrated development environment, introduced with OSX 10.5 (Leopard). +# To create a documentation set, doxygen will generate a Makefile in the +# HTML output directory. Running make will produce the docset in that +# directory and running "make install" will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find +# it at startup. +# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. + +GENERATE_DOCSET = NO + +# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the +# feed. A documentation feed provides an umbrella under which multiple +# documentation sets from a single provider (such as a company or product suite) +# can be grouped. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that +# should uniquely identify the documentation set bundle. This should be a +# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen +# will append .docset to the name. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING +# is used to encode HtmlHelp index (hhk), content (hhc) and project file +# content. + +CHM_INDEX_ENCODING = + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated +# that can be used as input for Qt's qhelpgenerator to generate a +# Qt Compressed Help (.qch) of the generated HTML documentation. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can +# be used to specify the file name of the resulting .qch file. +# The path specified is relative to the HTML output folder. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#namespace + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating +# Qt Help Project output. For more information please see +# http://doc.trolltech.com/qthelpproject.html#virtual-folders + +QHP_VIRTUAL_FOLDER = doc + +# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to +# add. For more information please see +# http://doc.trolltech.com/qthelpproject.html#custom-filters + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see +# +# Qt Help Project / Custom Filters. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's +# filter section matches. +# +# Qt Help Project / Filter Attributes. + +QHP_SECT_FILTER_ATTRS = + +# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can +# be used to specify the location of Qt's qhelpgenerator. +# If non-empty doxygen will try to run qhelpgenerator on the generated +# .qhp file. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files +# will be generated, which together with the HTML files, form an Eclipse help +# plugin. To install this plugin and make it available under the help contents +# menu in Eclipse, the contents of the directory containing the HTML and XML +# files needs to be copied into the plugins directory of eclipse. The name of +# the directory within the plugins directory should be the same as +# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before +# the help appears. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have +# this name. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. +# If the tag value is set to YES, a side panel will be generated +# containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = YES + +# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, +# and Class Hierarchy pages using a tree view instead of an ordered list. + +USE_INLINE_TREES = YES + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open +# links to external symbols imported via tag files in a separate window. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of Latex formulas included +# as images in the HTML documentation. The default is 10. Note that +# when you change the font size after a successful doxygen run you need +# to manually remove any form_*.png images from the HTML output directory +# to force them to be regenerated. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are +# not supported properly for IE 6.0, but are supported on all modern browsers. +# Note that when changing this option you need to delete any form_*.png files +# in the HTML output before the changes have effect. + +FORMULA_TRANSPARENT = YES + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box +# for the HTML output. The underlying search engine uses javascript +# and DHTML and should work on any modern browser. Note that when using +# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets +# (GENERATE_DOCSET) there is already a search function so this one should +# typically be disabled. For large projects the javascript based search engine +# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution. + +SEARCHENGINE = YES + +# When the SERVER_BASED_SEARCH tag is enabled the search engine will be +# implemented using a PHP enabled web server instead of at the web client +# using Javascript. Doxygen will generate the search PHP script and index +# file to put on the web server. The advantage of the server +# based approach is that it scales better to large projects and allows +# full text search. The disadvances is that it is more difficult to setup +# and does not have live searching capabilities. + +SERVER_BASED_SEARCH = NO + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. +# Note that when enabling USE_PDFLATEX this option is only used for +# generating bitmaps for formulas in the HTML output, but not in the +# Makefile that is written to the output directory. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +# If LATEX_SOURCE_CODE is set to YES then doxygen will include +# source code with syntax highlighting in the LaTeX output. +# Note that which sources are shown also depends on other settings +# such as SOURCE_BROWSER. + +LATEX_SOURCE_CODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = NO + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see +# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is +# allowed to run in parallel. When set to 0 (the default) doxygen will +# base this on the number of processors available in the system. You can set it +# explicitly to a value larger than 0 to get control over the balance +# between CPU load and processing speed. + +DOT_NUM_THREADS = 0 + +# By default doxygen will write a font called FreeSans.ttf to the output +# directory and reference it in all dot files that doxygen generates. This +# font does not include all possible unicode characters however, so when you need +# these (or just want a differently looking font) you can specify the font name +# using DOT_FONTNAME. You need need to make sure dot is able to find the font, +# which can be done by putting it in a standard location or by setting the +# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory +# containing the font. + +DOT_FONTNAME = FreeSans.ttf + +# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. +# The default size is 10pt. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the output directory to look for the +# FreeSans.ttf font (which doxygen will put there itself). If you specify a +# different font using DOT_FONTNAME you can set the path where dot +# can find it using this tag. + +DOT_FONTPATH = + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT options are set to YES then +# doxygen will generate a call dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable call graphs +# for selected functions only using the \callgraph command. + +CALL_GRAPH = YES + +# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then +# doxygen will generate a caller dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable caller +# graphs for selected functions only using the \callergraph command. + +CALLER_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of +# nodes that will be shown in the graph. If the number of nodes in a graph +# becomes larger than this value, doxygen will truncate the graph, which is +# visualized by representing a node as a red box. Note that doxygen if the +# number of direct children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note +# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not +# seem to support this out of the box. Warning: Depending on the platform used, +# enabling this option may lead to badly anti-aliased labels on the edges of +# a graph (i.e. they become hard to read). + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = YES + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES diff --git a/doc/Rapport post-doc/1-introduction.tex b/doc/Rapport post-doc/1-introduction.tex new file mode 100644 index 0000000..e3c17c6 --- /dev/null +++ b/doc/Rapport post-doc/1-introduction.tex @@ -0,0 +1,134 @@ +\section{Toward an automated model-based approach to system validation} +\label{sec:intro} + + +The increasing complexity of interactions between functions and other equipment in modern +industrial systems poses new technical challenges. +In fact, developing complex systems often raise integration problems during the product +final testing and verification phase. Besides, correcting these issues +often generates a heavy rework and is a well-known cause for cost +overruns and project delays. + +We have to say that operation of complex systems is traditionally informally expressed in design documents as a set of modes representing functions, equipments and monitoring mechanisms, which are validated by review, i.e. exhaustive manual (opposed to automatic) consistence checks and cross-reading. +Human validation activities soon became practically impossible due to the high number of combinations to be checked. + Therefore, finding and applying powerful computer-aided analysis techniques that + contribute to anticipate and resolve integration problems as early + as possible in the design process has become a prior concern for the industry. + + +We believe that formalizing and validating the specifications through animation/simulation and model-checking has several strong advantages +wrt ``traditional approaches''. On the one hand, modelling during the specification phase forces the designer to formalise and clarify the specifications. Animation/simulation is useful for validating the model against the specifications and for identifying behaviour inconsistencies based on relevant user-defined scenarios. Such inconsistencies are difficult to identify in a classical purely paper-based specification process. Last, formal verification proves that none of the possible execution scenarios violates the system properties. Such approaches are useful not only for validating an architecture or failure detection, isolation and reconfiguration strategies once defined, but also for tuning its parameters during the definition phase. + +It is worth noting that the approach and tools described in these pages, while embracing the automated validation of properties over model-described complex systems via model checking, also extends the existing tools to permit the analysis of temporal properties. In fact, +in order to have a complete vision and control over a system, it is necessary to be able to grasp transient states, and system dynamics. + + +\subsection{Classical safety analysis techniques: FTA and FMEA} +Fault Tree Analysis (FTA)~\cite{stamatelatos2002fault} and Failure Mode Effects Analysis (FMEA)~\cite{FMEA} are well-known and widely used system analysis techniques used in reliability +engineering. Both are long established -- FMEA was formally introduced in the late 1940s, and FTA has been around since the +1960s -- and both have been employed in a number of different areas, including the aerospace, nuclear power, and automotive industries. +They are methods that we can use to identify potential faults in a system, so that we can then use that information to correct or prevent those faults. + +Fault Tree Analysis is equally applicable to quantitative and qualitative analyses, and easy to +use and understand. Fault trees themselves are graphical representations of logical combinations of failures, and show the +relationship between a failure or fault and the events that cause them: they normally consist of a top event, which is +typically a system failure, connected to one or more basic events via a system of logical gates, such as AND and OR. Basic +events are usually either component failures or events expected to happen as part of the normal operation of the system. +Analysis of the fault tree consists of two parts: qualitative (logical) analysis, and quantitative (probabilistic) analysis. +Qualitative analysis is performed by reducing the logical expression represented by the fault tree into a set of minimal cut sets, +which are the smallest possible combinations of failures required to cause the top event. Quantitative analysis is performed +by calculating the probability of the top event given the probability of each of the basic events occurring. + +In an FMEA, the basic process consists of compiling lists of possible component failure modes (all the ways in which an +entity may fail), gathered from descriptions of each part of the system, and then trying to infer the effects of those failures +on the rest of the system. Usually, these effects are evaluated according to a number of criteria, such as severity, probability, +and detectability, and often these criteria are then combined into an overall estimate of risk. All of this data is then presented +in the form of a table which allows the analyst see what the effects of each failure mode are. + +Even if useful, the usage of those manual techniques is hindered by the increasing complexity of systems: it is becoming more and more difficult to +incorporate FTA or FMEA in the design cycle of systems that are more than relatively simple and manageable. +In complex systems, however, manual analysis is laborious and error prone, and a thorough assessment and interpretation of the results becomes increasingly +difficult to achieve within the constraints of most projects. Furthermore, the results of the analyses are separated from the +design being analysed, meaning that the effects of any changes in the system design may only become apparent after another +long and costly analysis~\cite{papadopoulos2011HH}. + +Complex systems yield a need for specific supporting measures and tools to +assist in the application of analysis techniques. One obvious approach would be to automate at least part of the process. This +would mean that the analyses could be carried out more quickly and efficiently, leaving more time for the results to be studied and allowing more useful conclusions to be drawn. + +\subsection{Modern safety analysis techniques: MBSE and MBSA} + + +New modelling techniques, such as MBSE or MBSA, propose to master the +combinatorial complexity at early concept phases by using abstract +high level representations of a system~\cite{Stamatis}. These views constitute a +promising ground to implement early validation techniques of the +architectures. But, in order to be profitable and implemented by the +industry, those validation techniques must remain lightweight and well +integrated in the system design process. That is to say, the modelling +workload must be limited, and the analysis results (even preliminary) +must be available at the same time as designers evaluate the +possible architecture choices. These requirements have driven our research and the toolchain described in those pages. + +As written above, modern safety analysis techniques permit a wealth of information about the safety and reliability of a +system to be gathered much more quickly and easily than ever before. This information gives to the designers the means to use safety and +reliability as a major factor in the decisions they make during the evolution of a system design: by evaluating the effects of +one or more potential design choices, e.g. increased reliability at the expense of greater cost or increased weight, etc., designers are able to make informed choices. +However, just as classical manual safety analyses restrict the rate that information can be obtained about a system, manually evaluating different design choices is time-consuming and restricts the number of design candidates that can be investigated. If this process could be automated, it would be possible to examine hundreds or thousands of potential design +candidates -- a much greater portion of the total design space -- and thus hopefully provide a better foundation for the next +iteration of the system design. + + + + +\section{Automated Evaluation of Safety Temporal Conditions} +In this report, we describe an approach that allows us to extend models +developed for safety analysis in order to reason about the correctness +of temporal conditions. +We intend to offer the capability to study a +new range of system requirements that can be of main interest for +functions such as failure detection, isolation and recovery. We +advocate that timing properties are critical when assessing the safety +of embedded and real-time systems. Indeed, temporal aspects---like +network delays or computation times---can be the cause of missed +failure detections or undesired reactions to (delayed) failure +propagation. It is therefore necessary to be able to analyse the +temporal properties of a model in order to build systems that will +operate as intended in a real-world environment. + + + +We define a model-based process to check simultaneously safety and temporal +conditions on systems. Our approach is based on an extension of the +AltaRica language~\cite{arn00} where timing constraints can be +associated with events. This extension can then be translated into the +intermediate language Fiacre~\cite{berthomieu2008fiacre}, a formal +specification language that can be used to represent both the +behavioural and timing aspects of systems. This Fiacre model can be +analysed with the realtime model-checker Tina~\cite{BRV04}. The +results of model-checking shed light on the dysfunctional behaviour of +the original model, including how the cascading effects due to failure +propagation delay reveal transitory failure modes~\cite{albore2017IMBSA}. +The approach scales up on models of industrial scale, like in the validation +of formation flying satellite systems where complex equipment and instruments are distributed over several spacecrafts~\cite{albore2018ERTS}. + +The translation developed takes the functional part of the system model and the dysfunctional viewpoint modelled by safety engineers to generate an AltaRica model of the system. The generated AltaRica model is formal and allows, one from another, the dysfunctional simulation of the system and the generation of sequences of events leading to accidents.\\ + + + +%%%% + +This report is organised as follows. We start by giving a wider vision about the subject +by revising the state of the art~\ref{soa}. We then define the AltaRica and the Fiacre +language and the time model in Chap.~\ref{altarica}, providing examples of the encoding of AltaRica in Fiacre, +and giving some experimental results about time failure propagation +in Sect.~\ref{sec:sect4}. +In Chap.~\ref{aocs} we apply the described approach to an industrial case of (automated) verification +on AOCS modes in satellites, and discuss scalability issues and empirical results. + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: + +%% LocalWords: Fiacre diff --git a/doc/Rapport post-doc/2-motivation.tex b/doc/Rapport post-doc/2-motivation.tex new file mode 100644 index 0000000..4076a40 --- /dev/null +++ b/doc/Rapport post-doc/2-motivation.tex @@ -0,0 +1,400 @@ +\section{Example of a Failure Detection and Isolation System} +\label{sec:example-fail-detect-1} + +We study the example of a safety critical function that illustrates +standard failure propagation problems. We use this example to show the +adverse effects of temporal failure propagation even in the presence +of % system safety improvements. In our case the addition of +Failure Detection and Isolation (FDI) safety capabilities. + +This example is inspired by the avionic functions that provide +parameters for Primary Flight Display (PFD), which is located in the +aircraft cockpit. The system of interest is the computer that acquires +sensors measurements and computes the aircraft \emph{calibrated airspeed + } (CAS) parameter. Airspeed is crucial for pilots: it is taken into +account to adjust aircraft engines thrust and it plays a main role in +the prevention of over speed and stall. + +%% +\begin{figure}[tb] + \centering +\includegraphics[width=0.99\textwidth]{figures/AirSpeed_Computation.jpg} + \caption{Functional and physical views of the airspeed computation function.\label{fig:cockpit}} +\end{figure} +%% + +CAS is not directly measured by a dedicated sensor, but is computed as +a function of two auxiliary pressure measurements, the static pressure +(Ps) and total pressure (Pt); that is +$\mathrm{CAS} = f(\mathrm{Pt}, \mathrm{Ps})$. +% \begin{equation*} +% CAS = C_{SO}\sqrt{5 \cdot \left( \left(\frac{Pt - Ps}{P_0} + 1\right)^{2/7} - 1\right)} +% \end{equation*} +% with $C_{SO}$ and $P_0$ two +% constants. % the speed of sound under standard day sea level conditions +These two measurements come from sensors located on the aircraft nose, +a pressure probe and a pitot tube. +% Our proposed functional view shows: +% \begin{itemize} +% \item Two external functions \I{1} and \I{2} that measure static and total pressure. They represent the functions allocated to the sensors. +% \item Three inner functions of the system: \F{1} and \F{2} for sensor measurements acquisition by the onboard computer and \F{3} for airspeed computation. +% \item The PFD functions have not been modelled in the sole purpose of simplification. +% \end{itemize} +% +%% + +Our proposed functional view is given in Fig.~\ref{fig:cockpit}. It +consists in two external functions \I{1} and \I{2} that measure static +and total pressure; and three inner functions of the system, \F{1} and +\F{2} for sensor measurements acquisition by the onboard computer and +\F{3} for airspeed computation. For simplification purposes, the +PFD functions have not been modelled. + +Next, we propose a first failure propagation view aiming at +identifying the scenarios leading to an erroneous airspeed computation +and display to the pilot (denoted \ERR). Such failure can only be +detected if a failure detector is implemented, for instance by +comparing the outputs of different functions. Undetected, it could +mislead the pilot and, consequently, lead to an inappropriate engine +thrust setting. We also want to identify the scenarios leading to +% (clearly) erroneous transmitted values, for instance a variable out of bounds or +the loss of the measure (denoted \LOSS). In such a case, the pilot can +easily assess that the measure is missing or false and consequently +rely upon another measure to control the aircraft (note that such +redundancy is not modelled). For example, airspeed out of +bound---indicating that an airliner has crossed the sonic barrier---is +considered to be of kind \LOSS. It can be unserstood that scenarios leading to the +loss of the airspeed are less critical than the ones leading erroneous +values. + +% We consider two possible kinds of fail status: the ``silent'' failure of +%an element (denoted \ERR); or a communication problem with one of the +% functions (denoted \LOSS). + +% A failure is typically a loss of connectivity or the +% detection of (clearly) erroneous transmitted values, for instance a +% variable out of bounds. A \LOSS fail is less critical than an \ERR +% since it can be detected immediately and isolated. On the other hand, +% an \ERR fail can only be detected if a failure detector is +% implemented, for instance by comparing the outputs of different +% functions. In the remainder of this paper, we consider that the status +% are ordered by their level of severity, that is \ERR $<$ \LOSS $<$\OK. + + +\subsubsection*{Safety model of the architecture without FDI.} +%%\label{sec:error-prop-simple} +%For the sake of brevity, we choose to study a simplified version of +%FDI system. While simple, this system is representative of failure +%propagation mechanisms found in actual onboard systems. To simplify +%the presentation, we start by describing the system without any +%safety-related elements, see Fig.~\ref{fig:example0}. +%% +% +We provide an AltaRica model corresponding to the functional structure +of the CAS function in Fig.~\ref{fig:example0}. This model, tailored +to study failure propagation, is comprised of: +% ( All the functions are modelled according to the node function +% introduced in the Sect.~\ref{sec:sect2}. +% +two external functions, \I{1} and \I{2}, that have no input (so, in +their nominal state, the output is set to \OK); two inner functions, +\F{1} and \F{2}, which are instances of the node \FUNC described in +Sect.~\ref{sec:sect2}; and a function, \F{3}, that is the composition +of two basic elements: a multiplexer, \MIN, representing the +dependence of the output of \F{3} from its two inputs; and a computing +element \F{3Processing} that represents the computation of the +airspeed. \F{3Processing} is also an instance of node \FUNC. + +\begin{figure}[t] + \centering + \begin{tikzpicture} + \node[anchor=south west,inner sep=0] at (0,0) { \includegraphics[width=0.7\textwidth]{figures/Modele0}}; + \draw[red!50,ultra thick, dashed] (6.7,2.6) rectangle (2.6,0.5); + \node[red] at (6.3,2.3) {\texttt{\large F3}}; +\end{tikzpicture} + \caption{A simple example of failure propagation.\label{fig:example0}} +\end{figure} +% +In case of single failure scenario, \MIN propagates the failure coming +either from one input or the other. In case of multiple failures, when +both inputs have identical failure, this one propagates. For instance, +both inputs to \LOSS lead to an output of \LOSS. +% But when it receives an erroneous fail then the multiplexer will +% propagate an \ERR. The remaining failure combination drew our +% attention during \F{3} modelling. +On the other hand, when different failures propagate, one being \LOSS +and the other being \ERR,---and without appropriate FDI---the system +outcome is uncertain. +% +Solving this uncertainty would require a detailed behavioural model of +the onboard computer and a model for all the possible failure modes, +which is rarely feasible with a sufficient level of confidence, except +for time-tested technology. Given this uncertainty, it is usual to +retain the state with the most critical effect, that is to say: +% in this case, \MIN can be thought of as a simple logic operator that +% computes the minimum of its two inputs, and +the output of \F{3} is \ERR. + + +% Since a \LOSS can be ``easily'' detected, we want to avoid a situation +% where the whole system propagates \ERR while one of its +%internal element propagates a \LOSS. The rationale is that we should be +% able to isolate (or quarantine) the system when we know for sure that +% one of its element does not reliably respond to commands. This can be +% expressed by the following safety property. +%% + +% In the next section, we study the system with the addition of FDI +% capabilities. + +Our goal is to prevent the computation of an erroneous airspeed while +one of \F{3} input signals is lost. The rationale is that the system +should be able to passivate automatically the airspeed when it detects +that one of its input signals is not reliable. This behavior can be +expressed with the following property. + + +%The goal of the safety engineer is to avoid a situation where \F{3} +%propagates an erroneous value while one of its input propagates a +%\LOSS. The rationale is that we should be able to isolate (or +% quarantine) the function when we can detect that one of its element is +% not reliable. This can be expressed by the following safety property. +%% +\begin{prop}[Loss Detection and Instantaneous Propagation]\label{prop:1} + A function is \emph{loss detection safe} if, when in nominal mode, it + propagates a \LOSS whenever one of its input nodes propagates a + \LOSS. +\end{prop} + +% This is a simple system used to detect non-nominal behaviours +% and to trigger observables in order to isolate the failure mode. +% ({The figures are actual screen capture of models edited with Cecilia +% OCAS.}) +% \subsubsection{Analysis} + + +We can show that our example of Fig.~\ref{fig:example0} does not meet +this property using the \emph{Sequence Generation} tool available in +Cecilia OCAS. +%% +% This system has several sources of unreliability. Both its sources and +% the computing elements (\F{1}, \F{2} and \F{3Processing}) can +% experience spontaneous failures, meaning that their outputs can +% transition instantaneously to \LOSS or \ERR. Errors are irrecoverable; +% once a function becomes faulty, its output will always stay equal to +% \LOSS or \ERR. Likewise, if both inputs are ``nominal'' then the +% output of \MIN is \OK. We assume that the multiplexer cannot undergo +% spontaneous failures. +%% +% This can be tested using a perfect detectors, \FF{3}{Loss}, placed at +% the output of the system. +%% +To this end, we compute the minimal cuts for the target equation +$((\text{\F{1.O.Loss}} \vee \text{\F{2.O.Loss}}) \wedge \neg +\text{\F{3.O.Loss}})$, meaning the scenario where \F{3} does not +propagates \LOSS when one of \F{1} or \F{2} does. Hence function \F{3} +is {loss detection safe} if and only if the set is empty. +% \footnote{To check the safety of \F{3}, we need to perform the same +% analysis for all the elements that can propagate a loss fail, not +% only \F{1}.}. + +In our example, once we eliminate the cases where \F{3} is not nominal +(that is when \F{3Processing} is in an error state), we find eight +minimal cuts, all of order $2$. In the following section, we correct +the behaviour of \F{3} by considering a new architecture based on +detectors and a switch to isolate the output of \F{3} when faulty. + +%% +% {%\centering +% \begin{small} +% \begin{tabular}{c@{\quad\quad}c} +% \begin{minipage}[t]{0.42\linewidth} +% \begin{verbatim} +% {'F1.fail_err', 'F2.fail_loss'} +% {'F1.fail_err', 'I2.fail_loss'} +% {'F1.fail_loss', 'F2.fail_err'} +% {'F1.fail_loss', 'I2.fail_err'} +% \end{verbatim} +% \end{minipage} +% & +% \begin{minipage}[t]{0.42\linewidth} +% \begin{verbatim} +% {'F2.fail_err', 'I1.fail_loss'} +% {'F2.fail_loss', 'I1.fail_err'} +% {'I1.fail_err', 'I2.fail_loss'} +% {'I1.fail_loss', 'I2.fail_err'} +% \end{verbatim} +% \end{minipage}\\ +% \end{tabular}\\ +% \end{small} +% } +%% +% Each of these cuts lead to trivial violations of our safety +% property. For instance, we obtain the cut \code{\{'F1.fail\_err', +% 'F2.fail\_loss'\}} that corresponds to the case where \F{1} +% propagates \ERR and \F{2} propagates \LOSS, in which case \F{3} +% propagates \ERR. This is exactly the situation that we want to +% avoid. + + +\begin{figure}[bt] + \centering + \begin{tikzpicture} + \node[anchor=south west,inner sep=0] at (0,0) { \includegraphics[width=\textwidth]{figures/Modele2.png}}; + \draw[red!50,ultra thick, dashed] (10.8,3.4) rectangle (2,0); + \node[red] at (10.4,3.1) {\texttt{\large F3}}; +\end{tikzpicture} + \caption{Model of a FDI function with a switch and an alarm.\label{fig:example1}} +\end{figure}%\vspace*{-1cm} + +%\enlargethispage{\baselineskip} + +\subsubsection*{Safety model of the architecture with FDI.} +%%\label{sec:simple-fail-detect} +%% +%In order to satisfy the Prop.~\ref{prop:1}, +We update our implementation of \F{3} (see Fig.~\ref{fig:example1}) +using two perfect detectors, \F{1Loss} and \F{2Loss}, that can detect +a loss fail on the inputs of the function. The (Boolean) outputs of +these detectors are linked to an OR gate ({\ttfamily AtLeastOneLoss}) +which triggers an \ALARM when at least one of the detectors outputs +true. The alarm commands a \SWITCH; the output of \SWITCH is the same +as \MIN, unless \ALARM is activated, in which case it propagates a +\LOSS fail status. The alarm can fail in two modes, either +continuously triggering the switch or never being activated. The +schema also includes two delays operators, \D{1} and \D{2}, that can +be used to model delay propagations at the input of the detectors. We +will come back to these timing constraints at the end of this section. + +% \TODO{why do we need Alarm ! why does the alarm can fail ! we could +% plug directly the or gate to the switch}- Permanent failure of the alarm. + +The FDI function---with a switch and an alarm---is a stable scheme for +failure propagation: when in nominal mode, it detects all the failures +of the system and it is able to disambiguate the case where its inputs +contains both \ERR and \LOSS. Once again, this can be confirmed using +the Sequence Generation tool. If we repeat the same analysis than +before---and if we abstract away the delays nodes---we find $56$ +minimal cuts, all involving a failure of either \ALARM or +\F{3Processing}. This means that, in an untimed model, our new +implementation of \F{3} satisifies the loss detection property, as +desired. +% \begin{figure}[hbt] +% \centering +% \begin{tikzpicture} +% \node[anchor=south west,inner sep=0] at (0,0) { \includegraphics[width=\textwidth]{figures/Modele2.png}}; +% \draw[red,ultra thick, dashed] (10.6,3.6) rectangle (2.2,0); +% \node[red] at (10,3) {\texttt{\huge F3}}; +% \end{tikzpicture} +% % \includegraphics[width=0.95\textwidth]{figures/Modele2} +% \caption{Taking into consideration propagation delays in the FDI +% system.\label{fig:example2}} +% \end{figure} +% Unfortunately, this model makes unrealistic assumptions about the +% instantaneous failure propagation of detection. Indeed, it may be the +% case that the outputs of \F{1} and \F{2} are delayed as they are +% propagated to the observers \F{1Loss} and \F{2Loss}. Next, we study +% new failure modes that may arise from this situation and how we can +% detect them. +%% +% \subsection{Timed Safety model of the architecture with FDI} +% \label{sec:timed-safety-model} +%% +% In this section, we consider a new AltaRica model that takes into +% account propagation delays. To this end, we may insert two instances +% of the delay node (the element \PRE defined in Sect.~\ref{sec:sect2}) +% before the detectors \F{1Loss} and \F{2Loss}. +Even so, it is easy to find a timed scenario where the safety property +is violated. + +Assume now that \F{1} and \F{2} propagate respectively the status \LOSS and \ERR, + at the same date. In such a case, the output of \F{1} +might reach \F{1Loss} at successive date of the output of \F{2} +reaching \F{2Loss}, while \ERR reaches \MIN instantaneously. This +leads to a transient state where the alarm is not activated whereas +the output of \MIN is set to \ERR. This brings us back to the same +dreaded scenario than in our initial model. +%% +% In particular, this scenario corresponds to the cut +% \code{\{'F1.fail\_loss', 'F2.fail\_err'\}}, that is not admissible in +% an untimed semantics. +%% + +This example suggests that we need a more powerful method to compute +the set of cuts in the presence of temporal constraints. On the other +hand, we may also advocate that our safety property is too strong in +this context, where perfect synchronicity of events is rare. Actually, +we can prove that the output of \F{3} will eventually converge to a +loss detection and isolation (assuming that \F{3} stays nominal and +that its inputs stay stable). Therefore, if we can bound the latency +needed to detect the loss failure, and if this bound is sufficiently +small safety-wise, we could still deem our system as safe. To reflect +this situation, we propose an improved safety property that takes into +account temporal conditions. +%% +\begin{prop}[Loss Detection Convergent]\label{prop:2} A function is + \emph{loss detection convergent} if (when in nominal mode) there + exists a duration $\Delta$ such that it continuously outputs a \LOSS + after the date $\delta_0 + \Delta$ if at least one of its input + nodes continuously propagates a \LOSS starting from $\delta_0$ + onward. The smallest possible value for $\Delta$ is called the + \emph{convergence latency} of the function. +\end{prop} + + + +In the next section, we use our approach to generate a list ``timed +cuts'' (as model-checking counterexamples) that would have exposed the +problems that we just described. We also use model-checking to compute +the {convergence latency} for the node \F{3}. In this simple example, +we can show that the latency is equal to the maximal propagation delay +at the input of the detectors. The value of the latency could be much +harder to compute in a more sophisticated scenario, where delays can +be chained and/or depends on the internal state of a component. + +% The failure to detect a lost element in the system strongly affects +% the safety assessment process, and motivates our approach to take +% directly into account temporal constraints when analysing AltaRica +% models. Unfortunately, while it is possible to define some timing +% constraints on AltaRica synchronizations using ``Dirac events'', this +% information is not taken into account during analysis. In particular, +% we cannot use the Sequence Generation tool to find the ``timed'' +% minimal cuts that would expose the problems that we just described. In +% the next section, we propose a way to check our timed extension of +% AltaRica using a translation into the Fiacre specification +% language. After translation into this new format, the model can be +% used by a realtime model-checker Tina. + +% \TODO{Limitations of OCAS are described above as well: to integrate the two parts} +% \TODO{talk about Dirac(2) in AltaRica as a way to do some crude +% temporal constraints. It works in simulation mode in Cecilia OCAS but +% no tooling !? actually I am not sure.} + +% \subsubsection{Dialects of AltaRica} +% AltaRica is a high level modelling language dedicated to Safety Analysis. +% The semantics of AltaRica is formally defined in terms of Guarded Transitions Systems, and the state of the system is described by means of variables~\cite{poi99}. The system changes of state are dictate by events, i.e. the transitions between states happen only when an event occurs as it is the only mechanism updates the value of variables. + +% Few versions of AltaRica exist; we consider here AltaRica 2.0 Dataflow, a version where variables are updated by propagating values in a fixed order, and this order is determined at compilation time. + +% The model we realised used CECILIA as a tool, then brought to a more +% standard AltaRica 2.0 version (the one of Epoch). + +% \subsection{Cecilia OCAS graphical interactive simulator} +% %% Pris de l'article de Christel +% The system architecture we modelled can be realised using Cecilia OCAS graphical interactive simulator, which has the capacity of exporting AltaRica code, in a dialect that can easily be translated in AltaRica DataFlow. + +% Each system component is modelled by an AltaRica node +% that can be regarded as a mode automaton~\cite{rauzy02}. In Cecilia +% OCAS, each node is associated to an icon and belongs to a library. +% Components are dragged and dropped from the library to the system +% architecture sheet and then linked graphically. + +% As failures are events in the AltaRica model, the safety engineer can use the graphical capacities of the tool to communicate more easily the model characteristics to other project members, as graphical representations are possibly the easiest way to communicate models, not only for the safety engineers. +% This tool permits to inject in the model a number of failure events in order to observe whether a failure condition is reached (such as loss of one or several elements). + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: + +%% LocalWords: PFD OCAS CAS Ps Fiacre diff --git a/doc/Rapport post-doc/2-sota.tex b/doc/Rapport post-doc/2-sota.tex new file mode 100644 index 0000000..ce31331 --- /dev/null +++ b/doc/Rapport post-doc/2-sota.tex @@ -0,0 +1,173 @@ +% State of the Art + +\section{Modelling languages for Safety Analysis} +% modelling languages + + +In AltaRica, a system is expressed in terms of variables constrained +by formulas and transitions. Several versions of the language have +been defined (see for instance~\cite{arn00,prosvirnova2013altarica}). +Underlying mathematical model...... + +AltaRica will be described more deeply in Sec.~\ref{sec:altarica}. +% Tempora lproperties for safety + +OpenAltarica~\citep{prosvirnova2013altarica} relies on propagation based variable update, but the order in which this propagation +takes place in determined at execution time. Technically, a fixpoint is computed. This new update +scheme does not increase much computation times but extends significantly the expressiveness of the +language. It makes it possible to handle looped systems, i.e. systems in which variables depend of each +other in a circular way. Another new feature of AltaRica 3.0 is the notion of guarded synchronization +that both increases the expressiveness and unifies transitions and synchronizations + + +Several model-based approaches have been proposed, each with their associated tooling, in order to cope with the complexity of analyzing sophisticated safety architectures and scenarios. However, rare are the languages that come equipped with tools that can perform formal analysis of timed models. + +Figaro language~\citep{bouissou05} is an alternative language for failure propagation model which introduces time via stochastic events, while we express temporal constraints on the triggering of events. Figaro models can be analyzed with stochastic simulators which are relevant to assess performance of the system (e.g. an estimation of the false detection rate). As far as we know, there is no translation from Figaro to timed model checking tools in order to verify whether a software logic satisfies applicable deterministic timed requirements. +Several works have combined model-checking and AltaRica. The archetypal example is the MEC tool~\citep{mec5} that was developed at the same time as the language. More recently, Bozzano et al.~\citep{bozzano2012} have defined a transformation from AltaRica Dataflow to the symbolic model-checker NuSMV. While this tool does not support complex timing constraints, it offers some support for Dirac laws (and implicit priorities) by encoding an ad-hoc scheduler. + +COMPASS uses the SLIM language, a subset of AADL, for modelling safety architectures. It can automatically generate fault trees, which can be evaluated to determine the probabilities of failures. The FDIR design process and analysis relies, for describing temporal events on fault propagation, on the so-called TFPM (Timed Failure Propagation Models)~\citep{bittner2014}. + +AADL (Architecture Analysis and Design Language) is a multi-concerns modelling language dedicated to distributed real-time embedded systems~\cite{aadl}. +AADL has been enriched with several annexes to describe embedded system behvior; for instance, the Error Model V2 (EMV2) is an error annex that focuses on Safety analyses. +EMV2 offers a terminology and an ontology to capture key features of failure propagations, like permanent and transient errors events. EM2V supports AADL to PRISM export into a PRISM model, in order to process model-checking method using the Markov-Chain formalism~\cite{PRISM}; i.e. probabilistic model analysys. The PRISM input language is a simple, state-based language. We discuss furter the PRISM model-checker in sec.~\ref{modelsota}. + +UPPAAL is a non-deterministic guarded command language with data types description language. It serves as a modeling or design language to describe system behavior as networks of +timed automata extended with data variables. A simulator and a model-checker are designed for interactive and automated analysis of system behavior by manipulating and solving constraints that represent the state-space of a system description. +Validating a FDIR approach in satellite architecture has been done in project AGATA~\citep{rugina09} by coupling simulation with model-checking, focusing significant part of the system and abstracted away the rest of it using UPPAAL~\cite{uppaal1997}. + +\section{Safety Assessment on Temporal Properties} + +% Who does that + + +Our approach provides a solution to +model safety timing constraints within AltaRica, also providing an +automatic transformation from Time AltaRica models in one of the +input formats of Tina, showing how two interesting +problems---computing ``timed cuts'' and bounding the convergence +latency of a node---can be reduced to a decidable model-checking +problem. %% TODO: Complete with FDIR results, and underline the needs filled. + +Several works have combined model-checking and AltaRica, the +archetypal example being the MEC tool~\cite{mec5,griffault2004mec} that was +developed at the same time as the language. More recently, Bozzano +et al~\cite{bozzano2012} have defined a transformation from AltaRica +Dataflow to the symbolic model-checker NuSMV. While this tool does not +support complex timing constraints, it offers some support for Dirac +laws (and implicit priorities) by encoding an ad-hoc scheduler. The +use of symbolic model-checking techniques is interesting in the case +of models with a strong combinatorial blow up, like for instance model +HYDRAU of Sect.~\ref{sec:sect4}. Nonetheless, even though Tina also +includes BDD-based tools, no approaches allow to combine the advantages +of both realtime and symbolic model-checking techniques. + + +Other model-based approaches aim at assessing the dependability of safety-critical dynamic systems. +HiP-HOPS~\cite{papadopoulos2011engineering} is a tool for safety analysis that can generate automatically fault-trees and FMEA tables from extended system models, as well as perform quantitative analysis on fault trees and multi-objective optimisation of the system model. + +In Pandora~\cite{walker2009pandora}, Temporal Fault Trees allow to model dynamic behaviours with temporal gates, while temporal laws are used for qualitative analysis. +This approach specifies directly the dynamic failure behaviour of components through a formalism for dynamic dependability, on the other side, using a model-based approach (e.g. modelling with AltaRica), the failure propagation mechanism is directly inferred by the analysis tool from the undelying model. + + + +Realtime techniques are central to our approach. As we will see in Sect.\ref{sec:sect2}, we define an +extension of AltaRica, Time AltaRica, where timing constraints can be declared using {temporal laws} of the form \code{law (evt) = "[a,b]"}, with a +semantics inspired by Time Petri nets. As a result, we can apply on +Time AltaRica several state space abstractions techniques that have been +developed for ``timed models'', such as the use of DBM and state +classes~\cite{BRV04}. In a different way, Cassez et +al.~\cite{pagetti2004} have proposed an extension of AltaRica with +explicit ``clock variables'', inspired by Timed Automata, where clocks +are real-valued flow variables that can be used inside the guards of +events. +%% +% (Which means that there are restrictions on the type of equations +% one can use in the \code{assert} declaration of a node.) +%% +% They also define an algorithm to compile this extension into +% Uppaal~\cite{larsen1997uppaal}. +Their work is mainly focused on the verification of behavioural +properties and focuses on the encoding of urgency and priorities +between events, two notions that are naturally offered in +Fiacre. Also, our extension is less invasive. If we ignore the +\code{extern} declaration then we obtain valid AltaRica code. More +research is still needed to further the comparison between these two +approaches in the context of safety assessments. + +Aside from these works on AltaRica, recent works +centred on combining failure propagation analysis and timing constraints, +define an automatic method for +synthesising \emph{Timed Failure Propagation Graphs} (TFPG), that is +an extension of the notion of cut-sets including information on the +date of events~\cite{bittner2016}. TFPG provide a condensed representation that is easier +to use than sets of timed cuts. Therefore, it would be interesting to +use this format in our case. + + +\section{Model-checking approach to safety assessment} +\label{modelsota} +Several model-checkers have been used in industrial or academic +projects to perform safety analysis. Besides Tina from LAAS, that we discuss further in Sect.~\ref{sec:tina}, +UPPAAL, MEC, ARC, PRISM, and NuSMV are the model-checkers more widely used in this domain. + +UPPAAL~\cite{uppaal1997} provides a model-checker. It is designed to check for invariant +and reachability properties. Other properties, such as bounded liveness +properties, can be checked by reasoning about the system +in the context of testing automata or simply decorating +the system description with debugging information and +then checking reachability properties. Model-checking is +performed by a module which takes as input +a network of automata in the textual UPPAAL format +and a formula. + +Mec 5~\cite{mec5} is a model-checker for finite AltaRica models. +Properties are verified by testing that the set of states which violate the property is +empty. These properties are expressed in a specification language that allows the definition +of complex relations between different models, e.g. bisimulation. + +The AltaRica Checker (ARC)\cite{arc} is a toolbox for the AltaRica language. ARC is aimed at model-checking systems described with AltaRica. +It also gathers several tools for the analysis or compilation of AltaRica models, like the support for Mec 5 specifications, translators for the LUSTRE language~\cite{Griffault06}, +and a simulator for models decorated with stochastic informations. + +PRISM~\cite{PRISM} is a probabilistic model checker used for formal modelling and analysis of systems that exhibit random or probabilistic behaviour. + It incorporates symbolic data structures and algorithms, based on BDDs (Binary Decision Diagrams) and MTBDDs (Multi-Terminal Binary Decision Diagrams)~\cite{KNP04b}. It also includes a discrete-event simulation engine, providing support for approximate/statistical model checking, and implementations of various different analysis techniques, such as quantitative abstraction refinement and symmetry reduction. + a model-checking tool for processing Markov-Chain. It supports different models such as Discrete Time Markov-Chain (DTMC) or Continuous Time Markov-Chain (CTMC). + It has been used to analyse systems from many different application domains. + +NuSMV~\cite{nusmv} (New Symbolic Model Verifier) is a symbolic model checker, supporting verification techniques such as BDD-based and SAT-based techniques. It allows to check finite state systems against specifications in the temporal logic for CTL and LTL. The input language of NuSMV is designed to allow the description of finite state systems that range from completely synchronous to completely asynchronous. The NuSMV language (like the language of SMV) provides for modular hierarchical descriptions and for the definition of reusable components. + + Besides, translators between these languages exist, in certain cases. +Even if generally the translation concerns subsets of the languages expressivity, it makes possible testing +tools and compare modelling techniques. Notable examples, are the AADL EMV2 to AltaRica translation~\cite{brunel2017performing}, or the pioneer work from +an AADL subset (System-Level Integrated Modelling (SLIM) language) to NuSMV, aimed at achieving formal analysis via model-checking in the framework of the COMPASS project~\cite{bozzano2010safety}. + + +\subsection{Tina model-checker}\label{sec:tina} +Tina (TIme Petri Net Analyzer, \url{http://www.laas.fr/tina}) is a +software environment to edit and analyze Petri Nets and Time +Petri Nets~\cite{BRV04}. +Time Petri nets~\cite{merlin1976} are one of the most widely used model +for the specification and verification of real-time systems: +they extend Petri nets with temporal intervals associated with +transitions, specifying firing delay ranges for the transitions. +In addition to the usual editing and analysis facilities of +similar environments, Tina offers various abstract state space +constructions that preserve specific classes of properties of +the state spaces of nets, like absence of deadlocks, linear +time temporal properties, or bisimilarity. For untimed systems, +abstract state spaces helps to prevent combinatorial explosion. +For timed systems, abstractions are mandatory as their state +spaces are typically infinite, Tina implements various abstractions based on state classes. + +We used Tina as mode-checker (via the tool \emph{selt}) for the toolchain described in these pages +for its capacities with Temporal Petri Nets, and its performances as model-checker. +In addition, several model-checkers are being developed specifically for Tina. +The first available, \emph{selt}, is a model-checker for an enriched version +of State/Event -- LTL checking ~\cite{chaki2004}, a linear time temporal logic +supporting both state and transition properties. For the properties found false, a timed counter example is +computed and can be replayed by the simulator \emph{play}, also present in Tina's software suite. + +Then, Tina can present its results in a variety of formats, +understood by model checkers like MEC~\cite{mec5}, a $\mu$-calculus +formula checker, or behavior equivalence checkers like Bcg, +part of the CADP toolset~\cite{cadp}. diff --git a/doc/Rapport post-doc/3-imbsa.tex b/doc/Rapport post-doc/3-imbsa.tex new file mode 100644 index 0000000..505368a --- /dev/null +++ b/doc/Rapport post-doc/3-imbsa.tex @@ -0,0 +1,884 @@ + + +Failure propagation models are defined by safety engineers and are +usually obtained through manual assessment of the safety of the +system. This is a complicated task since failures can depend on more +than one element of the system; be the result of the interaction +between many faults; be the consequence of the missed detection of +another fault (e.g. a fault inside an element tasked with detecting +faults); etc. To cope with the complexity of the systems and the +scenarios that need to be analysed, several model-based approaches +have been proposed such as AltaRica~\cite{Altarica2.3,arnold1999altarica}, Figaro~\cite{bouissou05}, etc. each with their +associated tooling. + + +Our work is concerned with the modelling and analysis of failures +propagation in the presence of time constraints. We concentrate on a +particular safety property, called \emph{loss detection convergence}, +meaning that the system applies an appropriate and timely response +to the occurrence of a fault before the failure is +propagated and produces unwanted system behaviours. +% +Similar problems +were addressed in~\cite{thomas2013}, where the authors describe a +process to model Failure Detection Isolation and Reconfiguration architecture (for use on-board satellites) that +requires to take into account failure propagation, +detection, and recovery times. However, these needs are not matched by +an effective way to express or check the safety constraints of the system. + + +Our contribution is as follows. We define a lightweight extension of +AltaRica, meaning that timing constraints are declared separately from +the behaviour of a system (Sect.~\ref{sec:sect2}). Therefore it is easy to reuse a prior +safety model and to define its temporal behaviour afterwards. We +illustrate our method with an example inspired by safety architectures +found in avionic systems. This example illustrate the impact of time +when reasoning about failure propagation, and we use it to +show that taking into accounts timing constraints---in particular +propagation delays---can help finding new failure modes that cannot be +detected in the untimed models currently in use. In the process, we +define two safety properties: \emph{loss detection}; and its temporal +version, \emph{loss detection convergence}, meaning that a system +applies an appropriate and timely response to the occurrence of a +fault before the failure is propagated and produces unwanted system +behaviours. We show that these two properties, which are of interest +in a much broader context, can be reduced to effective model-checking +problems. + +In the next chapter we extend this approach, by applying it to an industrial +satellite study case, and analysing the scalability of the methodology to more +complex system models. + + +\section{Model-Based Safety Analysis with AltaRica}\label{sec:sect2} + + +\subsection{AltaRica language and versions} + + +AltaRica is a high level modelling language dedicated to Safety +Analysis. It has been defined to ease the modelling and analysis of +failure propagation in systems. The goal is to identify the +possible failure modes of the system and, for each mode, the chain of +events that lead to an unwanted situation. + + +In AltaRica, a system is expressed in terms of variables constrained +by formulas and transitions. Several versions of the language have +been defined (see for +instance~\cite{arn00,prosvirnova2013altarica}). + + + +Three main versions of AltaRica have been designed so far. These three versions differ essentially with +two respects: the way variables are updated after each transition firing and the way hierarchies of +components are managed. In the first version, designed at the Computer Science Laboratory of +University of Bordeaux (LaBRI), variables were updated by solving constraint systems. This model, +although very powerful, was too resource consuming for industrial scale applications. A radical turn +was therefore taken with the design of a data-flow version of the language. In AltaRica 2.0 Dataflow, +variables are updated by propagating values in a fixed order. This order is determined at compile time. +At the time this document is written, most of AltaRica tools rely on this Dataflow version. Ongoing investigation aim +at improving AltaRica Dataflow in several ways, like propagating variable values by determining a fixpoint at execution time, +hence justifying the third version of +the language currently being developped: AltaRica 3.0 or OpenAltaRica\cite{prosvirnova2013altarica}. + +\subsection{AltaRica modelling} +In this work, we use the AltaRica 2.0 Dataflow language which is a fragment of other +versions and which is sufficient to analyse the behaviour of computer +based systems. (The approach discussed here could be applied to other +AltaRica dialects.) The models used in this work have been edited and +analysed using Cecilia OCAS, a graphical interactive simulator +developed by Dassault Aviation~\cite{bieber2004safety}. + +An AltaRica model is made of interconnected \emph{nodes}. A node can +be essentially viewed as a mode automaton~\cite{rauzy02} extended with +guards and actions on data variables. A node comprises three parts: a +declaration of variables and events, the definition of transitions, +and the definition of assertions. We illustrate these concepts with +the example of a simple node called \FUNC. We give the code (textual +definition) of \FUNC in Listing~\ref{ls:altarica} and a schematic +representation in Fig.~\ref{fig:funct2}. The node \FUNC has one input, +\code{I}, and one output, \code{O}. + +\lstinputlisting[language=Altarica,float=bht,captionpos=b,caption=\protect{Example + of AltaRica code for the node \FUNC.},frame=single,label=ls:altarica]{algos/function2.alt} + +\begin{figure}[thb] + \centering + \begin{minipage}{0.25\textwidth} + \centering + \includegraphics[width=\textwidth]{altarica-function.pdf} + \end{minipage} + \begin{minipage}{0.7\textwidth} + \centering + \vspace{1em} + \includegraphics[width=0.8\textwidth]{altarica-diagrams.pdf} + \end{minipage} + \caption{Graphical representation of node \FUNC (left) and its + associated failure mode automaton (right).\label{fig:funct2}}\vspace{1em} +\end{figure} + +\enlargethispage{\baselineskip} +% +Nodes can have an internal state stored in a set of \emph{state + variables}, declared in a heading called \texttt{state}. In its +nominal state (when \code{S = NOMINAL}), the \FUNC node acts as a +perfect relay: it copies on its output the value provided by its input +(we have \code{O = I}); this is expressed in the \code{assert} +block. On the opposite, its output is set to \LOSS or \ERR when +\code{S} equals \code{LOST} or \code{ERROR}, respectively. +% +The assert directive is used to express constraints on the values of +the input and output variables of a node, also called \emph{flow + variables}, establishing a link between the node and its +environment, i.e. the other interconnected nodes. It distinguishes +between input (\texttt{in}) and output (\texttt{out}) variables. An +assertion defines a rule to update the value of output flows according +to the state of the component and the value of input flows. + +The state variables of a node can only change when an +event is triggered. The code of \FUNC declares two events: \code{fail\_err}, that +changes the state from \code{NOMINAL} to \code{ERROR}, and +\code{fail\_loss}, that can transition from any state to +\code{LOST}. This behaviour is the one displayed on the mode +automaton of Fig.~\ref{fig:funct2}. Transitions are listed in the +\texttt{trans} block of the node. Each transition has an (event) +name and a definition of the form +\lstinline[language=Altarica]{g |-evt-> e}, where the guard \code{g} +is a Boolean condition that can refer to state and flow +variables. The event \code{evt} can be triggered when the guard is +satisfied. In this case we apply the effect, \code{e}, that is an +expression that modifies the values of state variables. + +Events are useful to model the occurrence of failures or the reaction +to conditions on the flow variables. +% It is possible to indicate +% whether an event is triggered internally by a node---as in the case of +% a reconfiguration---or externally by its environment---as in the case +% of the occurrence of a failure. In the latter case, +We can assign a +law of probability on the occurrence of the failure using the heading +\code{extern}. For instance we could assert that event +\code{fail\_loss} follows an exponential distribution with the +declaration: +%% +{\lstinline[language=Altarica]{extern law ()="exp 1e-4";}} +%% +In the next section, we propose a way to enrich this syntax to express +timing constraints on events instead of probability distributions. At +the moment, it is not possible to use stochastic events in addition to +time events. + +\enlargethispage{\baselineskip} + +In the general case, an AltaRica model is composed of several +interconnected node instances, following a component-based +approach. Global assertions relate the input flows of a component to +the output flows of other components. For the sake of brevity, we do +not describe component synchronisation here and we refer the reader to +\cite{Altarica2.3} for further details. More importantly, a +hierarchical AltaRica model can always be ``flattened'', i.e. +represented by a single node containing all the variables, events, +assertions, and transitions from the composite system. We use this +property in our interpretation of AltaRica in Fiacre. + +%% +\subsection{Time AltaRica: Adding Timing Constraints to Events}%%\label{sec:adding-timing-constr} +%% +There already is a limited mechanism for declaring timing constraints +in AltaRica. It relies on the use of external law associated with a +\emph{Dirac distribution}. An event with Dirac$(0)$ law denotes an +instantaneous transition, that should be triggered with the highest +priority. Likewise, an event with Dirac($d$) (where $d$ is a +positive constant) models a transition that should be triggered with a +delay of $d$ units of time. +% +In practice, Dirac laws are rather a way to encode priorities between +events than an actual mean to express duration. Moreover, while Dirac +laws are used during simulation, they are not taken into account by +the other analysis tools. Finally, the use of Dirac laws is not +expressive enough to capture non-deterministic transitions that can +occur within time intervals of the form $[a, b]$, where $a \neq +b$. These constraints are useful to reason about failure propagation +delays with different best and worst case traversal time. For this +reason, we propose to extend event properties with \emph{temporal + laws} of the form: +%% +{\lstinline[language=Altarica]{extern law (evt) = "[a,b]";}} +%% +It is also possible to use open and/or unbounded time intervals, such +as \code{]a,}$\infty$\code{[}.%%\scriptstyle + +With such a declaration, the transition +\lstinline[language=Altarica]{g |-evt-> e} can be triggered only if +the guard \code{g} is satisfied for a duration (or \emph{waiting + time}) $\delta$, with $\delta \in [a, b]$. A main difference with +the original semantics of AltaRica is that the timing constraint of an event is +not reinitialised unless its guard is set to false. +%% +% Hence the waiting time of an event decreases when time elapse whereas, +% while with a Dirac($d$) law the waiting time is reset to $d$ each time +% the event fires. Finally, +Moreover, our semantics naturally entails a notion of \emph{urgency}, +meaning that it is not possible to miss a deadline: when $\delta$ +equals $b$, then either \code{evt} is triggered or another transition +should (instantaneously) change the value of the guard \code{g} to +false. + +We can illustrate the use of temporal laws with the following example of a new +node, \PRE; see Listing.~\ref{ls:pre}. This node encodes a buffer that +delays the propagation of its input. When the input changes, event +\code{pre\_read} has to be triggered instantaneously. Then, only after +a duration $\delta \in [a, b]$, the value stored by \PRE (in the state +variable \code{Stored}) is propagated to its output. +% +\lstinputlisting[language=Altarica,float=t,captionpos=b,caption=\protect{Example + of Time AltaRica code: the basic delay.},frame=single,label=ls:pre]{algos/pre.alt} + + +\section{A Definition of Fiacre Using Examples}\label{sec:sect3} + +Fiacre~\cite{berthomieu2008fiacre} is a high-level, formal +specification language designed to represent both the behavioural and +timing aspects of reactive systems. Fiacre programs are stratified in +two main notions: \emph{processes}, which are well-suited for modelling +structured activities (like for example simple state machines), and +\emph{components}, which describes a system as a composition of +processes. In the following, we base our presentation of Fiacre on +code examples used in our interpretation of Time AltaRica. +% \subsection{A Definition of Fiacre by Examples} +% \label{sec:defin-fiacre-exampl} +We give a simple example of Fiacre specification in +Listing~\ref{lst:fiacre}. This code defines a process, +\code{Function}, that simulates the behaviour of the AltaRica node +given in Listing~\ref{ls:altarica}. + +\lstinputlisting[language=Fiacre,float=hbt,captionpos=b,caption=\protect{Example + of Fiacre code: type, functions and processes},label=lst:fiacre,frame=single]{algos/function.fcr} + +Fiacre is a strongly typed language, meaning that type annotations are +exploited in order to avoid unchecked run-time errors. Our example +defines two enumeration types, \code{FState} and \code{FailureType}, +that are the equivalent of the namesake AltaRica domains. We also +define a record type, \code{Flows}, that models the environment of the +node \code{Function}, that is an association from flow variables to +values. Fiacre provides more complex data types, such as arrays, +tagged union or FIFO queues. Fiacre also supports native +\emph{functions} that provide a simple way to compute on values. In +our example, function \code{update} is used to compute the state of +the environment after an event is triggered; that is to model the +effect of assertions in AltaRica. It uses two ternary (conditional) +operators to mimic the \code{case}-expression found in the +\code{assert} heading of Listing~\ref{ls:altarica}. + +% Functions are evaluated applicatively (there are no side effects) and +% can be recursively defined. + +A Fiacre \emph{process} is defined by a set of parameters and {control + states}, each associated with a set of \emph{complex transitions} +(introduced by the keyword \code{from}). Our example defines a process +with two {shared variables}---symbol \code{\&} denotes variables +passed by reference---that can be updated concurrently by other +processes. In our case, variable \code{S} models the (unique) state +variable of node \FUNC. + +Complex transitions are expressions that declares how variables are +updated and which transitions may fire. They are built from constructs +available in imperative programming languages (assignments, +conditionals, sequential composition, \dots); non-deterministic +constructs (such as external choice, with the \code{select} operator); +communication on ports; and jump to a state (with the \code{to} or +\code{loop} operators). In Listing~\ref{lst:fiacre}, the \code{select} +statement defines two possible transitions, separated by the symbol +\code{[]}, that loop back to \code{s0}. Each transition maps exactly +to one of the AltaRica events, \code{fail\_loss} and \code{fail\_err}, +that we want to translate. Transitions are triggered +non-deterministically and their effects are atomic (they have an ``all +or nothing'' semantics). A transition can also be guarded by a Boolean +condition, using the operator \code{on} or another conditional +construct. + +It is possible to associate a time constraint to a transition using +the operator \code{wait}. Actually, the ability to express directly +timing constraints in programs is a distinguishing feature of +Fiacre. We illustrate this mechanism in the code below, that +corresponds to the interpretation of the node \PRE of +Listing~\ref{ls:pre}. Basically, a transition constrained by a (time) +interval $I$ can be triggered after a time $\delta$, with +$\delta \in I$, only if its guard stayed continuously valid during +this time. It is this behaviour that inspired our choice of semantics +for the temporal law. + +The last notion that we need to introduce is \emph{components}. + Components allow the hierarchical composition of processes, in the + same way than AltaRica nodes can be composed into classes in order to + build more complex behaviors. +Thus, a Fiacre component defines a parallel composition of components and/or +processes using statements of the form \code{par} \vars{P}$_0$ +$\parallel \dots \parallel$ \vars{P}$_n$ \code{end}. It can also be +used to restrict the visibility of variables and ports and to define +priorities between communication events. +% Priorities are explicitly declared as constraints between +% communication ports, as in \code{go1 > go2}. +We give an example of Fiacre component in Listing~\ref{lst:pre2}, +where we define an upgraded version of the delay operator \PRE. +% +\lstinputlisting[language=Fiacre,float=bt,captionpos=b,caption=\protect{Wait statement, components and synchronisation on ports.},label=lst:pre2,frame=single]{algos/pre2.fcr} + +% % +% \lstinputlisting[language=Fiacre,float=bt,captionpos=b,caption=\protect{Example +% of Fiacre code: declaring timing +% constraints},label=lst:pre1,frame=single]{algos/pre.fcr} +% % + + +A problem with the implementation of \PRE is that at most one failure +mode can be delayed at a time. Indeed, if the input of \PRE changes +while the state is \code{Full}, then the updated value is not taken +into account until after event \code{pre\_wait} triggers. +% +It is not possible to implement a version that can delay an unbounded +number of events in a bounded time; this would require an unbounded +amount of memory to store the intermediate values. More fundamentally, +this would give rise to undecidable verification problems (see +e.g.~\cite{bouyer2004updatable}). To fix this problem, we can define a +family of operators, \PRE\code{\_k}, that can delay up-to $k$ +simultaneous different inputs. Our implementation relies on a +component that uses three process instances: one instance of +\code{front}, that reads messages from the input (variable \code{I}), +and two instances of \code{delay}, that act as buffers for the values +that need to be delayed. Process \code{front} uses the local ports +\code{go1} and \code{go2} to dispatch values to the buffers. +Component \PRE\code{\_2} is enough to model the use case defined in +Sect.~\ref{sec:example-fail-detect-1}. Indeed, any element in the FDI +system may propagate at most two different status, one from \OK to +\LOSS and then from \LOSS to \ERR. + + + +\section{Example of a Failure Detection and Isolation System} +\label{sec:example-fail-detect-1} + +We study the example of a safety critical function that illustrates +standard failure propagation problems. We use this example to show the +adverse effects of temporal failure propagation even in the presence +of % system safety improvements. In our case the addition of +Failure Detection and Isolation (FDI) capabilities. +% +This example is inspired by the avionic functions that provide +parameters for Primary Flight Display (PFD), which is located in the +aircraft cockpit. The system of interest is the computer that acquires +sensors measurements and computes the aircraft \emph{calibrated airspeed} (CAS) parameter. +Airspeed is crucial for pilots: it is taken into +account to adjust aircraft engines thrust and it plays a main role in +the prevention of over speed and stall. + +%% +\begin{figure}[thb] + \centering + \includegraphics[width=1\textwidth]{figures/AirSpeed_Computation.jpg} + \caption{Functional and physical views of the airspeed computation function.\label{fig:cockpit}} +\end{figure} +%% + +CAS is not directly measured by a dedicated sensor, but is computed as +a function of two auxiliary pressure measurements, the static pressure +(Ps) and total pressure (Pt); that is +$\mathrm{CAS} = f(\mathrm{Pt}, \mathrm{Ps})$. +% \begin{equation*} +% CAS = C_{SO}\sqrt{5 \cdot \left( \left(\frac{Pt - Ps}{P_0} + 1\right)^{2/7} - 1\right)} +% \end{equation*} +% with $C_{SO}$ and $P_0$ two +% constants. % the speed of sound under standard day sea level conditions +These two measurements come from sensors located on the aircraft nose, +a pressure probe and a pitot tube. +% Our proposed functional view shows: +% \begin{itemize} +% \item Two external functions \I{1} and \I{2} that measure static and total pressure. They represent the functions allocated to the sensors. +% \item Three inner functions of the system: \F{1} and \F{2} for sensor measurements acquisition by the onboard computer and \F{3} for airspeed computation. +% \item The PFD functions have not been modelled in the sole purpose of simplification. +% \end{itemize} +% +%% + +Our proposed functional view is given in Fig.~\ref{fig:cockpit}. It +consists in two external input functions \I{1} and \I{2} that measure static +and total pressure; and three inner functions of the system, \F{1} and +\F{2} for sensor measurements acquisition by the on-board computer and +\F{3} for airspeed computation. For simplification purposes, the +PFD functions have not been modelled. + +Next, we propose a first failure propagation view aiming at +identifying the scenarios leading to an erroneous airspeed computation +and display to the pilot (denoted \ERR). Such failure can only be +detected if a failure detector is implemented, for instance by +comparing the outputs of different functions. Undetected, it could +mislead the pilot and, consequently, lead to an inappropriate engine +thrust setting. We also want to identify the scenarios leading to +the loss of the measure (denoted \LOSS). In such a case, the pilot can +easily assess that the measure is missing or false and consequently +rely upon another measure to control the aircraft (note that such +redundancy is not modelled). For example, airspeed out of +bound---indicating that an airliner has crossed the sonic barrier---is +considered to be of kind \LOSS. It can be understood that scenarios leading to the +loss of the airspeed are less critical than the ones leading erroneous +values. + +% We consider two possible kinds of fail status: the ``silent'' failure of +%an element (denoted \ERR); or a communication problem with one of the +% functions (denoted \LOSS). + + A failure is typically a loss of connectivity or the + detection of (clearly) erroneous transmitted values, for instance a + variable out of bounds. A \LOSS fail is less critical than an \ERR + since it can be detected immediately and isolated. On the other hand, + an \ERR fail can only be detected if a failure detector is + implemented, for instance by comparing the outputs of different + functions. In the following, we consider that the status + are ordered by their level of severity, that is \ERR $<$ \LOSS $<$\OK. + + +\subsubsection{Safety model of the architecture without FDI} +%%\label{sec:error-prop-simple} +For the sake of understandability, we choose to study a simplified version of +FDI system. While simple, this system is representative of failure +propagation mechanisms found in actual onboard systems. +%% + +We provide an AltaRica model corresponding to the functional view +of the CAS function in Fig.~\ref{fig:example0}. This model, tailored +to study failure propagation, is comprised of: +% ( All the functions are modelled according to the node function +% introduced in the Sect.~\ref{sec:sect2}. +% +two external functions, \I{1} and \I{2}, that have no input (so, in +their nominal state, the output is set to \OK); two inner functions, +\F{1} and \F{2}, which are instances of the node \FUNC described in +Sect.~\ref{sec:sect2}; and a function, \F{3}, that is the composition +of two basic elements: a multiplexer, \MIN, representing the +dependence of the output of \F{3} from its two inputs, and a computing +element \F{3Processing} that represents the computation of the +airspeed. \F{3Processing} is also an instance of node \FUNC. + +\begin{figure}[t] + \centering + \begin{tikzpicture} + \node[anchor=south west,inner sep=0] at (0,0) { \includegraphics[width=0.75\textwidth]{figures/Modele0}}; + \draw[red!50,ultra thick, dashed] (7,2.85) rectangle (2.6,0.5); + \node[red] at (6.5,2.5) {\texttt{\large F3}}; + \end{tikzpicture} + \caption{A simple example of failure propagation.\label{fig:example0}} +\end{figure} +% +In case of single failure scenario, \MIN propagates the failure coming +either from one input or the other. In case of multiple failures, +%when both inputs have identical failure, the faillure propagates; +%For instance, +% both inputs to \LOSS lead to an output of \LOSS. +% But when it receives an erroneous fail then the multiplexer will +% propagate an \ERR. The remaining failure combination drew our +% attention during \F{3} modelling. +%on the other hand, +when different failures propagate, one being \LOSS +and the other being \ERR,---and without appropriate FDI---the system +outcome is uncertain. +% +Solving this uncertainty would require a detailed behavioural model of +the on-board computer and a model for all the possible failure modes, +which is rarely feasible with a sufficient level of confidence, except +for time-tested technology. Given this uncertainty, it is usual to +retain the state with the most critical effect, that is to say: +% in this case, \MIN can be thought of as a simple logic operator that +% computes the minimum of its two inputs, and +the output of \F{3} is \ERR. + + +% Since a \LOSS can be ``easily'' detected, we want to avoid a situation +% where the whole system propagates \ERR while one of its +%internal element propagates a \LOSS. The rationale is that we should be +% able to isolate (or quarantine) the system when we know for sure that +% one of its element does not reliably respond to commands. This can be +% expressed by the following safety property. +%% + +% In the next section, we study the system with the addition of FDI +% capabilities. + +Our goal is to prevent the computation of an erroneous airspeed while +one of \F{3} input signals is lost. The rationale is that the system +should be able to passivate automatically the airspeed when it detects +that one of its input signals is not reliable. This behaviour can be +expressed with the following property: + +%% +\begin{prop}[Loss Detection and Instantaneous Propagation]\label{prop:1} + A function is \emph{loss detection safe} if, when in nominal mode, it + propagates a \LOSS whenever one of its input nodes propagates a + \LOSS. +\end{prop} + +% This is a simple system used to detect non-nominal behaviours +% and to trigger observables in order to isolate the failure mode. +% ({The figures are actual screen capture of models edited with Cecilia +% OCAS.}) +% \subsubsection{Analysis} + + +We can show that our example of Fig.~\ref{fig:example0} does not meet +this property using the \emph{Sequence Generation} tool available in +Cecilia OCAS. +%% +% This system has several sources of unreliability. Both its sources and +% the computing elements (\F{1}, \F{2} and \F{3Processing}) can +% experience spontaneous failures, meaning that their outputs can +% transition instantaneously to \LOSS or \ERR. Errors are irrecoverable; +% once a function becomes faulty, its output will always stay equal to +% \LOSS or \ERR. Likewise, if both inputs are ``nominal'' then the +% output of \MIN is \OK. We assume that the multiplexer cannot undergo +% spontaneous failures. +%% +% This can be tested using a perfect detectors, \FF{3}{Loss}, placed at +% the output of the system. +%% +To this end, we compute the minimal cuts for the target equation +$((\text{\F{1.O.Loss}} \vee \text{\F{2.O.Loss}}) \wedge \neg +\text{\F{3.O.Loss}})$, meaning the scenario where \F{3} does not +propagates \LOSS when one of \F{1} or \F{2} does. Hence function \F{3} +is {loss detection safe} if and only if the set is empty. + \footnote{To check the safety of \F{3}, we need to perform the same + analysis for all the elements that can propagate a loss fail, not + only \F{1}.}. + +In our example, once we eliminate the cases where \F{3} is not nominal +(that is when \F{3Processing} is in an error state), we find eight +minimal cuts, all of order $2$. In the following section, we correct +the behaviour of \F{3} by considering a new architecture based on +detectors and a switch to isolate the output of \F{3} when faulty: + +%% + {%\centering + \begin{small} + \begin{tabular}{c@{\quad\quad}c} + \begin{minipage}[t]{0.42\linewidth} + \begin{verbatim} + {'F1.fail_err', 'F2.fail_loss'} + {'F1.fail_err', 'I2.fail_loss'} + {'F1.fail_loss', 'F2.fail_err'} + {'F1.fail_loss', 'I2.fail_err'} + \end{verbatim} + \end{minipage} + & + \begin{minipage}[t]{0.42\linewidth} + \begin{verbatim} + {'F2.fail_err', 'I1.fail_loss'} + {'F2.fail_loss', 'I1.fail_err'} + {'I1.fail_err', 'I2.fail_loss'} + {'I1.fail_loss', 'I2.fail_err'} + \end{verbatim} + \end{minipage}\\ + \end{tabular}\\ + \end{small} + } +% + Each of these cuts lead to trivial violations of our safety + property. For instance, we obtain the cut \code{\{'F1.fail\_err', + 'F2.fail\_loss'\}} that corresponds to the case where \F{1} + propagates \ERR and \F{2} propagates \LOSS, in which case \F{3} + propagates \ERR. This is exactly the situation that we want to + avoid. + + +\begin{figure}[bt] + \centering + \begin{tikzpicture} + \node[anchor=south west,inner sep=0] at (0,0) { \includegraphics[width=\textwidth]{figures/Modele2.png}}; + \draw[red!50,ultra thick, dashed] (10.8,3.4) rectangle (2,0); + \node[red] at (10.4,3.1) {\texttt{\large F3}}; + \end{tikzpicture} + \caption{Model of a FDI function with a switch and an alarm.\label{fig:example1}} +\end{figure}%\vspace*{-1cm} +%\enlargethispage{\baselineskip} + +\subsubsection{Safety model of the architecture with FDI} +%%\label{sec:simple-fail-detect} +%% +%In order to satisfy the Prop.~\ref{prop:1}, +The updated implementation of \F{3} (see Fig.~\ref{fig:example1}) +uses two perfect detectors, \F{1Loss} and \F{2Loss}, that can detect +a loss failure event on the inputs of the function. The (Boolean) outputs of +these detectors are linked to an OR gate ({\ttfamily AtLeastOneLoss}) +which triggers an \ALARM when at least one of the detectors outputs +true. The alarm commands a \SWITCH; the output of \SWITCH is the same +as \MIN, unless \ALARM is activated, in which case it propagates a +\LOSS failure. The alarm can fail in two modes, either +continuously signaling a \LOSS or never being activated. The +schema in Fig.~\ref{fig:example1} also includes two delays operators, \D{1} and \D{2}, +that model delay propagation at the input of the detectors; +we will not consider them in the following lines, but come back to these timing constraints at the end of the section. + +% \TODO{why do we need Alarm ! why does the alarm can fail ! we could +% plug directly the or gate to the switch}- Permanent failure of the alarm. + +The FDI function---with a switch and an alarm---is a stable scheme for +failure propagation: when in nominal mode, it detects all the failures +of the system and it is able to disambiguate the case where its inputs +contains both \ERR and \LOSS. Once again, this can be confirmed using +the Sequence Generation tool. If we repeat the same analysis than +before---and if we abstract away the delay nodes---we find $56$ +minimal cuts, all involving a failure of either \ALARM or +\F{3Processing}, i.e. a non-nominal mode. This means that, in an untimed model, our new +implementation of \F{3} satisfies the loss detection property, as +desired. +% \begin{figure}[hbt] +% \centering +% \begin{tikzpicture} +% \node[anchor=south west,inner sep=0] at (0,0) { \includegraphics[width=\textwidth]{figures/Modele2.png}}; +% \draw[red,ultra thick, dashed] (10.6,3.6) rectangle (2.2,0); +% \node[red] at (10,3) {\texttt{\huge F3}}; +% \end{tikzpicture} +% % \includegraphics[width=0.95\textwidth]{figures/Modele2} +% \caption{Taking into consideration propagation delays in the FDI +% system.\label{fig:example2}} +% \end{figure} +% Unfortunately, this model makes unrealistic assumptions about the +% instantaneous failure propagation of detection. Indeed, it may be the +% case that the outputs of \F{1} and \F{2} are delayed as they are +% propagated to the observers \F{1Loss} and \F{2Loss}. Next, we study +% new failure modes that may arise from this situation and how we can +% detect them. +%% +% \subsection{Timed Safety model of the architecture with FDI} +% \label{sec:timed-safety-model} +%% +% In this section, we consider a new AltaRica model that takes into +% account propagation delays. To this end, we may insert two instances +% of the delay node (the element \PRE defined in Sect.~\ref{sec:sect2}) +% before the detectors \F{1Loss} and \F{2Loss}. +Even so, it is easy to find a timed scenario where the safety property +is violated. + +Assume now that \F{1} and \F{2} propagate respectively the status \LOSS and \ERR, +at the same date. In such a case and considering possible latencies, +while \ERR reaches \MIN instantaneously, +the output of \F{1} might reach \F{1Loss} at successive date. +% of the output of \F{2} reaching \F{2Loss},. +This leads to a transient state where the alarm is not activated whereas +the output of \MIN is set to \ERR. This brings us back to the same +dreaded scenario than in our initial model. +%% + In particular, this scenario corresponds to the cut + \code{\{'F1.fail\_loss', 'F2.fail\_err'\}}, that is not admissible in + an untimed semantics. +%% + +This example suggests that we need a more powerful method to compute +the set of cuts in the presence of temporal constraints. On the other +hand, we may also advocate that our safety property is too limiting in +this context, where perfect synchronicity of events is rare. Actually, +it can be proven that the output of \F{3} will eventually converge to a +loss detection and isolation mode (assuming that \F{3} stays nominal and +that its inputs stay stable). +% +To reflect +this si\-tua\-tion, we pro\-pose an improved safety property that takes into +account temporal properties of the system: +%% +\begin{prop}[Loss Detection Convergent]\label{prop:2} A function is + \emph{loss detection convergent} if (when in nominal mode) there + exists a duration $\Delta$ such that it continuously outputs a \LOSS + after the date $\delta_0 + \Delta$ if at least one of its input + nodes continuously propagates a \LOSS starting from $\delta_0$ + onward. The smallest possible value for $\Delta$ is called the + \emph{convergence latency} of the function. +\end{prop} +Hence, if the latency +needed to detect the loss failure can be bound, and if the bound is sufficiently +small safety-wise, we can still deem our system as safe. +In the example in Fig.~\ref{fig:cockpit}, this property can indicate for how long an erroneous airspeed is shown on the PFD to the pilot, +before the failure is isolated. + +In the next section, we use our approach to generate a list of ``timed +cuts'' (as model-checking counterexamples) that would have exposed the +aforedescribed problems. We also use model-checking to compute +the {convergence latency} for the node \F{3}. In this simple example, +we can show that the latency is equal to the maximal propagation delay +at the input of the detectors. The value of the latency could be much +harder to compute in a more sophisticated scenario, where delays can +be chained and/or depends on the internal state of a component. + + +\section{Compilation of AltaRica and Experimental evaluation}\label{sec:sect4} + +We have implemented the transformation outlined in +Sect.~\ref{sec:sect3}; the result is a compiler that automatically +generates Fiacre code from an AltaRica model. The compilation process +relies on the fact that it is possible to ``flatten'' a composition of +interconnected nodes into an intermediate representation, called a +\emph{Guarded Transition System} (GTS)~\cite{rau08}. A GTS is very +similar to a (single) AltaRica node and can therefore be encoded in a +similar way. Our tool is built using the codebase of the model-checker +EPOCH~\cite{epoch}, which provides the functionalities for the +syntactic analysis and the linking of AltaRica code. After +compilation, the Fiacre code can be checked using +Tina~\cite{BRV04}. As seen in Sect.~\ref{sec:tina}, the core of the Tina toolset is an +exploration engine that can be exploited by dedicated model-checking +and transition analyser tools. Tina offers several abstract state +space constructions that preserve specific classes of properties like +absence of deadlocks, reachability of markings, or linear and +branching time temporal properties. These state space abstractions are +vital when dealing with timed systems that generally have an infinite +state space (due to the use of a dense time model). In our +experiments, most of the requirements can be reduced to reachability +properties, so we can use on-the-fly model-checking techniques. +% and very ``aggressive'' abstractions. + +\begin{figure}[thb] + \centering + \includegraphics[width=\textwidth]{figures/passerelle.png} + \caption{Graphical representation of the AltaRica/Fiacre toolchain.\label{fig:toolchain}} +\end{figure} + +We interpret a GTS by a Fiacre process whose parameters consist of all +its state and flow variables. Each transition +\lstinline[language=Altarica]{g |-evt-> e} in the GTS is (bijectively) +encoded by a transition that matches the guard \code{g} and updates +the variables to reflect the effect of \code{e} plus the assertions. Each transition can +be labelled with time and priorities constraints to take +into account the \code{extern} declarations of the node. This +translation is straightforward since all the operators available in +AltaRica have a direct equivalent in Fiacre. Hence every +state/transition in the GTS corresponds to a unique state/transition +in Fiacre. This means that the state (reachability) graph of a GTS and +its associated Fiacre model are isomorphic. This is a very strong and +useful property for formal verification, since we can very easily +transfer verification artefacts (such as counterexamples) from one +model back to the other. + +The close proximity between AltaRica and Fiacre is not really +surprising. First of all, both languages have similar roots in process +algebra theory and share very similar synchronisation mechanisms. More +deeply, they share formal models that are very close: AltaRica +semantics is based on the product of ``communicating automata'', +whereas the semantics of Fiacre can be expressed using (a time +extension of) one-safe Petri nets. The main difference is that +AltaRica provide support for defining probabilities on events, whereas +Fiacre is targeted towards the definition of timing aspects. This +proximity in both syntax and semantics is an advantage for the +validation of our tool, because it means that our translation should +preserve the semantics of AltaRica on models that do not use extern +laws to define probabilities and time. We have used this property to +validate our translation by comparing the behaviours of the models +obtained using Cecilia OCAS simulation tool and their translation. For +instance, in the case of the CAS system of +Sect.~\ref{sec:example-fail-detect-1}, we can compute the set of cuts +corresponding to Safety Property~\ref{prop:1} (loss detection) by +checking an invariant of the form +$((\text{\F{1.O}} = \text{\code{Loss}}) \vee (\text{\F{2.O}} = +\text{\code{Loss}}) \Rightarrow (\text{\F{3.O}} = +\text{\code{Loss}}))$. +% +%%\TODO{Check if it is necessary to mention the tool, as opposed to counterexamples} +In both cases---with and without FDI---we are able to compute the +exact same set of cuts than Cecilia OCAS. This is done using the +model-checker for modal mu-calculus provided with Tina, which can list +all the counterexamples for a (reachability) formula as a graph. More +importantly, we can use our approach to compute the timed +counterexample described at the end of +Sect.~\ref{sec:example-fail-detect-1}. All these computations can be +done in less than a second on our test machine. + +\subsection{Empirical evaluation} +We have used our toolchain to generate the reachable state space of +several AltaRica models~\footnote{All the benchmarks tested in this paper are available at + https://w3.onera.fr/ifa-esa/content/model-checking-temporal-failure-propagation-altarica}: +RUDDER describes a control system for the +rudder of an A340 aircraft~\cite{bernard2007experiments}; ELEC refers +to three simplified electrical generation and power distribution +systems for a hypothetical twin jet aircraft; the HYDRAU model +describes a hydraulic system similar to the one of the A320 +aircraft~\cite{bieber2002combination}. The results are reported in +Table~\ref{table:2}. In each case, we indicate the time needed to +generate the whole state space (in seconds) and the number of states +and transitions explored. For information, we also give the number of +state variables as reported by Cecilia OCAS. All tests were run on an +Intel 2.50GHz CPU with 8GB of RAM running Linux. In the case of model +HYDRAU we stopped the exploration after $30$ minutes and more than +$9.10^{9}$ generated states. +The state space is large in this benchmark because it models the physical a-causal propagation of a leak, so a leak can impact both upward and backward components and trigger a reconfiguration, multiplying the number of reachable states. +Moreover, the topology of the system shall be reconfigurated after the detection of some failures and this dynamic reconfiguration combined with a-causal propagation increases again more the size of the state space. +In all cases, the time needed to generate +the Fiacre code is negligible, in the order of 10~ms. + +\begin{table}[tb] + \centering + \begin{tabular}{|l|c|c|c|c|c|} + \hline + \textbf{Model} & \textbf{time} (s) & \textbf{\# states} & + \textbf{\# + trans.} + & \textbf{\# state vars}\\ \hline + RUDDER~~~ & 0.85 & $3.3\,10^4$ & $2.5\,10^5$ & 15 \\ \hline + ELEC 01 & 0.40 & 512 & $2.3\,10^3$ & 9 \\ \hline + ELEC 02 & 0.40 & 512 & $2.3\,10^3$ & 9 \\ \hline + ELEC 03 & 101 & $4.2\,10^6$ & $4.6\,10^7$ & 22 \\ \hline + HYDRAU & 1800 & --- & --- & 59 \\ \hline + CAS~ & 0.40 & 729 & $2.9\,10^3$ & 6 \\ \hline + CAS with \PRE~~~ & 46 & $9.7\, 10^5$ & $4.3\, 10^6$ & 10 \\ \hline + \end{tabular} + \vspace*{1em} + \caption{State space size and generation time for several use cases.\label{table:2}} +\end{table} + +Our models also include two versions of the complete CAS system +(including the detectors, the alarm and the switch); both with and +without the delay functions \D{1} and \D{2}. The ``CAS with \PRE'' model +is our only example that contains timing constraints. In this case, we +give the size of the state class graph generated by Tina, that is an +abstract version of the state space that preserves LTL properties. We +can use Tina to check temporal properties on this +example. More precisely, we can check that \F{3} has the \emph{loss + detection convergence} property. To this end, a solution is to add a +Time Observer to check the maximal duration between two events: first, a \code{obs\_start} event is triggered when the output of \F{1} or \F{2} changes to \LOSS; +then an \code{obs\_end} event is triggered when the output of \F{3} changes to \LOSS. The +observer has also a third transition (\code{obs\_err}) that acts as a +timeout and is associated with a time interval $I$ and is enabled +concurrently with \code{obs\_end}. Hence, +Time Observer ends up in the state yield by \code{obs\_err} +when the output of \F{3} deviates from its +expected value for more than $d$ units of time, with $d \in I$. We +have used this observer to check that the \emph{convergence latency} +of the CAS system equals $3$, when +we assume that the +delays are in the time interval $[1, 3]$. +The result is that +\code{obs\_err} is fireable for any value of $d$ in the interval +$[0,3]$, while \code{obs\_err} is not fireable if $I = ]3, \infty[$. +% It is enough to indicate to choose $I = [0,3]$. +These two safety properties can be checked on the system (plus the +observer) in less than $0.6$~s. + + +% \begin{wraptable}{r}{0.35\textwidth} +% %\begin{table}[bth] +% \centering +% \vspace*{-7mm} +% \begin{tabular}{|c|c|l} +% \cline{1-2} +% \textbf{delay}$\mathbf\tau$ & \textbf{safety property} & \\ \cline{1-2} +% % {$\quad[4,4]\quad$} & ok & \\ \cline{1-2} +% {$]3, \infty[$} & holds & \\ \cline{1-2} +% {[}3,3{]} & not holds & \\ \cline{1-2} +% {[}0,3{]} & not holds & \\ \cline{1-2} +% \end{tabular} +% \caption{Latencies check on Eq.~\eqref{eq:mc1} +% with $\delta = [1,3]$.\label{table:1}} +% %\end{table} +% \end{wraptable} + + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: + +%% LocalWords: Fiacre diff --git a/doc/Rapport post-doc/4-aocs.tex b/doc/Rapport post-doc/4-aocs.tex new file mode 100644 index 0000000..f3c0b3b --- /dev/null +++ b/doc/Rapport post-doc/4-aocs.tex @@ -0,0 +1,300 @@ + +In order to assess the timed formal model approach, we apply it to an industrial case study, namely the validation of the automatic mode management model of an AOCS (Attitude and Orbit Control System) of a satellite. The full description is available in this report; the synthesis is published at ERTS 2018 conference. +\subsection*{Acronyms} +\begin{center} +\begin{table}[h!] + \begin{small} + \centering + \begin{tabular}{|c|c|} + \hline + \textbf{Term} & \textbf{Description} \\ + \hline + ACM & Attitude Control Mode \\ + \hline + ARO & Automatic Recondifiguration Order \\ + \hline + ASM & Acquisition and Safe Mode \\ + \hline + CAM & Collision Avoidance Manoeuvre \\ + \hline + FCM & Formation Control Mode \\ + \hline + GNC & Guidance, Navigation and Control \\ % Guidance and Navignatio Mode + \hline + IMU & Inertial Measurement Unit \\ + \hline + ISL & Inter-Satellite Link \\ + \hline + OCM& Orbit Control Mode \\ + \hline + OFF&OFF Mode \\ + \hline + PFailed&Permanent Failure\\ + \hline + STR&Star Tracker \\ + \hline + TC&Telecommand\\ + \hline + TFailed&Temporary Failure\\ + \hline + TM&Telemetry\\ + \hline + \end{tabular} + \end{small} +% \caption{Acronyms used} +\end{table} +\end{center} + + +\section{An Expression of Industrial Needs and Requirements}\label{sec:aocsintro} + +Failure Detection, Isolation and Recovery (FDIR) functions are implemented aboard satellites in order to detect the occurrence of failures and to prevent the failure from propagating in the whole system, which could cause critical events and thus jeopardize the mission. +The complexity of the FDIR verification and validation (V\&V) increases with the system complexity. As systems include more and more interacting functions and functional modes, it becomes harder to evaluate at the overall system level the effects of local failures. That is even truer when we consider the effects of time. Indeed, unexpected behavior can arise from a bad timing of events. Timing constraints allow to represent the impact of computation times, delays on the propagation of failures, and the reaction time of the reconfigurations steps triggered in reaction to failure detection. +Thus, new models and tools are needed to assist early V\&V of the on-board processes and FDIR design. Thomas and Blanquart~\cite{thomas2013} describe a process to model FDIR satellite functions. This process requires to model failure propagation, detection, and recovery times, which requires modelling languages expressive enough to support complex system modelling. Associated tools should provide automatic verification that on-board FDIR functions are correct despite latency in failure propagation or management. For instance, one should be able to verify whether failures are recovered before they are propagated further in the system. + +\begin{figure}[tb] + \centering + \includegraphics[width=\textwidth]{figures/satellite_telecom.png} + \caption{A satellite and its equipment} +\end{figure} + + + +\section{AOCS Case Study}\label{sec:aocs} + +The validation of the approach on the automatic mode management model of an AOCS (Attitude and Orbit Control System) of a satellite considers +control and command specifications of a satellite constellation mission. The example discussed in these pages is a simplification of this industrial specification which +takes into account a single function and 3 equipment per satellite. Each equipment is necessary to the execution of its function in any of its operational modes. +The real specification includes 3 functions, several equipment, surveillance elements and automata. +Validation can be done by simulation or property verification; the way we take here is the latter. + +\subsection{Architecture description} + +In space missions, the control of the attitude and the orbit of the aircraft is delegated to the AOCS. In the case study, the system relies on +\begin{itemize} + \item AOCS sensors: + \begin{itemize} + \item Inertial Measurement Unit (IMU) implements accelerometers which provide the acceleration and gyros which give the estimated angular speed; + \item Star-TRackers (STR) gives the estimated attitude quaternion; + \end{itemize} + \item AOCS actuators: Thrusters (ColdGasProp) permit the control of the spacecraft; + \item The On-Board Computer unit, which manages all the spacecraft’s activity and therefore the AOCS application software that acquires the information from the sensors and commands the actuators. +\end{itemize} + +\subsection{AOCS mode automaton} +The space industries and agencies contribute in the initiative Space AVionics Open Interface Architecture (SAVOIR) to define a single, agreed and common solution for the definition of the architecture of avionics system. The assess of our approach is validate with an industrial case study based on these Ground-Board Interface specifications\cite{ASRA}, the ECSS standard for the Space Segment Operability\cite{ECSS‐E‐ST‐70‐11C} and the AOCS mode management\cite{ECSS-E-ST-60-30C}. Generally, the specification of the satellite mode management is specified in early phases at system level with a co-engineering approach. The focus is on: +\begin{itemize} + \item The AOCS capabilities to control the attitude and the orbit of the satellite; + \item The Operations capabilities to operate the satellite by telecommand (TC) from the ground segment; + \item The FDIR capabilities to continue the mission operations and to survive critical situations without relying on ground intervention. +\end{itemize} + +In our approach, an early validation is experimented to increase the confidence on these system specifications and later to reduce the consolidation with the subsystems engineering. +The use-case focuses on the initial satellite mode management shown in Figure~\ref{fig:1}; the current representation of AOCS mode. + +\begin{figure}[thb] + \centering + \includegraphics[width=\textwidth]{figures/AOCSmode_schema.png}\vspace*{-5em} + \caption{Representation of the AOCS modes.\label{fig:1}} +\end{figure} + + +Several AOCS modes are designed for the different mission phases. +Switching between a mode and another depends on three possible reasons: +\begin{itemize} +\item either the satellite receives a telecommand (TC) from Earth to trigger a mode change (Acquisition \& Safe Mode, Attitude Control Mode, Orbit Control Mode, Formation Control Mode); +\item or there is an automatic on-board transition (A) when the separation from the launcher is detected or when the collision avoidance manoeuvre is finished; +\item or an automatic FDIR reconfiguration order (ARO) can be triggered by the ground (TC) or by the on-board FDIR to recover a failure. The ARO triggers the AOCS into the OFF mode and it is available from all AOCS mode except CAM. +\end{itemize} + +Transition between modes is possible only when the involved equipment is available. In fact, some devices can take tenths of minutes to be ready for a mode switch. This is why it is very important to take into account timing constraints. + +It is easy to understand that the planning and the reactivity to messages triggering a transition between modes is crucial, as failing to detect a message or reconfiguring in time would yield an unwanted mode. For instance, it could result in a transition into Safe Mode, which entails a heavy reboot and loss of scientific acquisition time. Many tasks of the mission depend on different inputs and are time-dependent; the temporal bounds of those tasks are the ones that we will analyse through formal V\&V in order to detect possible unwanted situations, or undetected failures through the system, in order to maintain the safety and mission autonomy objectives. + +Figure~\ref{fig:aocs} displays the AOCS mode automaton considered in the case study. This is a more precise version of the automaton of Fig.~\ref{fig:1} based on a SysML activity diagram that represents the transitions between mode and, for each AOCS mode, its associated state-machine. Each AOCS mode has essentially three states: an initial; a nominal; and a ``degraded'' state. +When the request of change mode is received, the AOCS triggers the initialization of equipment used by the mode in the Initial state and then it switches into the \emph{Nominal state} when all involved equipment are operational. The degraded state is triggered when the failure of used equipment is detected. All AOCS mode are described in the next subsections. + + +\begin{figure}[thb] + \centering + \includegraphics[width=1.1\textwidth]{{"figures/2-2 - AOCS mode automaton"}.png} + \caption{AOCS mode automaton.\label{fig:aocs}} +\end{figure} + +\begin{figure}[thb] + \centering + \includegraphics[width=.9\textwidth]{{"figures/2-3 - ASH mode"}.png} + \caption{Acquisition \& Safe mode automaton.\label{fig:asm}} +\end{figure} + +\begin{figure}[hbt] + \centering + \includegraphics[width=.6\textwidth]{{"figures/2-4 set ON the equipment for ASM mode"}.png} + \caption{Set ON equipment for ASM mode.\label{fig:asm-ON}} +\end{figure} + +\subsubsection{OFF mode} +In this mode, any equipment of use-case can be started. This mode is used when the satellite is in the launcher; and after an ARO to reestablish the satellite in safe conditions. +\subsubsection{Acquisition \& Safe mode (ASM)} +In this mode, the first acquisition in safe configuration is realized. The ASM automaton with the 3 states is shown in Figure \ref{fig:asm} When the TC to switch on ASM mode is received, the initialization of equipment used by ASM is started by the \texttt{EquipASM\_ON} activity (Figure~\ref{fig:asm-ON}). + +\begin{figure}[htb] + \centering + \includegraphics[width=\textwidth]{{"figures/2-5 ACM automaton"}.png} + \caption{Attitude Control Mode automaton.\label{fig:acm}} +\end{figure} + +\begin{figure}[bht] + \centering + \includegraphics[width=.6\textwidth]{{"figures/2-6 set ON the equipment for ACM mode"}.png} + \caption{Set ON equipment for ACM mode.\label{fig:acm-ON}} +\end{figure} + +\subsubsection{Attitude Control Mode (ACM)} +In this mode, the attitude is coarse controlled by the AOCS. The ASM automaton with the 3 states is shown in Figure~\ref{fig:acm}. When the TC to switch on ACM mode is received, the +initialization of equipment used by ACM mode is started by the \texttt{EquipASM\_ON} activity (Figure~\ref{fig:acm-ON}). + + +\subsubsection{Collision Avoidance Manœuvre (CAM)} +This case is used when the ground or FDIR triggers a manoeuvre to avoidance a collision with debris or other satellite. These specific TC are called CAM and they are only available +from the Attitude Control Mode, Orbit Control Mode and Formation Control Mode. So, the request of CAM is not possible from the Acquisition \& Safe Mode. + +The CAM automaton is described in Figure~\ref{fig:cam}. The exit of CAM is autonomous into ACM mode when the manoeuvre or predefined-timing is finished. + +\begin{figure}[htb] + \centering + \includegraphics[width=.6\textwidth]{figures/{"2-7 Collision Avoidance Mode"}.png} + \caption{Collision Avoidance Mode.\label{fig:cam}} +\end{figure} + +\subsubsection{Orbit Control Mode (OCM)} +In this mode, the orbit is controlled and the mission is suspended. The OCM automaton is shown in Figure~\ref{fig:ocm}. + +\begin{figure}[p] + \centering + \includegraphics[width=.8\textwidth]{figures/{"2-8 OCM automaton"}.png} + \caption{Orbit Control Mode.\label{fig:ocm}} +\end{figure} + +\subsubsection{Formation Control Mode (FCM)} +FCM is the nominal mode where the formation flying is operational. The FCM automaton with the 3 states is shown in Figure~\ref{fig:fcm}. + +\begin{figure}[p] + \centering + \includegraphics[width=.9\textwidth]{figures/{"2-9 Formation Control Mode"}.png} + \caption{Formation Control Mode.\label{fig:fcm}} +\end{figure} + + +\subsubsection{Equipment} + +The model is based on the following assumption: +\begin{itemize} + \item An equipment can be on, off, or faulty. + \item An equipment is started by the function that needs it. The reboot has a duration. + \item An equipment that is not useful in the current modes, is switched off. + \item The number of redundancies is a parameter defined for each equipment. + \item Temporary or permanent failures can affect an equipment\footnote{Those failures can be injected by the user.} only when it's running. + \begin{itemize} + \item After a temporary failure, the equipment is rebooted automatically. + \item After a permanent failure, the equipment moves over one of its available redundancies. If no redundancy is available, the state remains faulty. + \item When an ARO event is triggered, the equipment switches off. It can be switched on without moving to a redundancy by the functions. + \end{itemize} +\end{itemize} + +\begin{figure}[h] + \centering + \includegraphics[width=.5\textwidth]{figures/table1.png} + \caption{Allocation of the equipment on the modes.\label{tab:equip}} +\end{figure} + +\begin{figure}[bt] + \centering + \includegraphics[width=\textwidth]{figures/{"Equipment mode"}.png} + \caption{Equipment state machine.\label{fig:equip}} +\end{figure} + +Figure~\ref{fig:equip} also displays the state machine of an equipment. The IMU, ColdGasProp, and STR equipment have similar state machines. Equipment which is started from an ``OFF'' state, can only reach an ``ON'' state by passing through a ``Starting'' state. When a failure happens, the equipment makes a transition to state ``Failed''. If the failure is permanent, the equipment goes over the redundant equipment. If failure is temporary, state ``Starting'' can be restored with no further consequences. The allocation of equipment on modes is given by Table in Fig.~\ref{tab:equip}. For example, in our study case, the STR is used in four modes. + + +The AOCS, as all satellite systems, presents an increasing complexity of interactions between functions and other equipment, often raising design and integration issues during the product final testing and verification phases. Correcting these issues often generates a heavy rework and is a well-known cause for cost overruns and project delays. Moreover, the operation of space systems is traditionally informally expressed in design documents as a set of modes representing functions, equipments and monitoring mechanisms. Usually the mode dynamics of all the satellite systems and their interaction with the FDIR functions are validated by review, i.e. exhaustive manual (opposed to automatic) consistence checks and cross-reading. In case of formation flying, complex equipment and instruments are distributed over several spacecrafts. The human validation activities become practically impossible due to the high number of combinations to be analyzed. Powerful computer-aided analysis techniques are expected to help overcoming this issue. + +FDIR functions validation is particularly difficult, especially with ``traditional approaches'' because of the large number of interactions and not nominal situations, which increases the difficulty in analysing them. A large variety of points of view is necessary to fully analyse the behaviour of FDIR and its impact on dependability properties, including to be complete an explicit representation of the entities handled by FDIR: architecture, faults, time, etc. + +We believe that formalizing and validating the specifications through animation/simulation and model-checking has several strong advantages. On the one hand, modelling during the specification phase forces the designer to formalise and clarify the specifications. Animation/simulation is useful for validating the model against the specifications and for identifying behaviour inconsistencies based on relevant user-defined scenarios. Such inconsistencies are difficult to identify in a classical purely paper-based specification process. Last, formal verification proves that none of the possible execution scenarios violates the system properties. Such approaches are useful not only for validating an architecture or FDIR strategy once defined, but also for tuning its parameters during the definition phase. + +\section{Case study modelling} + +The original model of the AOCS case study comes from the validation of the FDIR of formation flying satellites. Formation flying requires specific techniques to ensure flight coordination and the safety of the spacecraft in case of anomaly. This requires giving more autonomy and complex decision-making mechanisms to the On-Board Computer unit. The SPaCIFY project~\cite{synoptic} described a similar architecture using the Synoptic language, in order to identify the needs in terms of guaranteeing traceability, validation, and general analysis---possibly using formal techniques---of the V-cycle of development~\cite{sutre09}. From this architecture, an AltaRica 1.0 version of the Synoptic model was generated automatically. We have used this initial AltaRica model and adapted it first to the AltaRica Dataflow syntax~\cite{Altarica2.3}. Then we can automatically translate this new model into Fiacre using our toolchain. + + +Validating a FDIR approach in satellite architecture has been done in project AGATA~\citep{rugina09} by coupling simulation with model-checking, the latter to prove that some given logical or timing properties hold in all states of a scenario generated by simulation. In AGATA the choice went in the same direction as us: focusing significant part of the system and abstracted away the rest of it using UPPAAL~\cite{uppaal1997}. +However, the model they performed model-checking was un-timed, with several variables used as clocks to track time, with the drawback that the size of the graph is exponential in the number of clocks~\cite{daws}, when Fiacre/Tina relies on a single clock. + + +\subsection{AltaRica modelling process} +In order to validate the FDIR software, the AltaRica model shall represent both the FDIR logic and the failure propagation in the hardware platform that is monitored and reconfigured according to the FDIR logic. During earlier design phase, AltaRica models without timing constraints can be used to abstract the details of the failure propagation paths and to support a preliminary safety and dependability analysis. Then the model details can be refined and timing information can be introduced in Time Altarica (see Chap.~\ref{altarica}). This will help system designers to verify critical properties when time-bounded reactions are required. On the application side, focusing on the interaction of FDIR mechanisms and AOCS modes is of an utmost importance when designing a space system. + +In this case study, we considered a quite detailed view of the FDIR logic related to the management of the AOCS and a simplified view of the satellite hardware. Next study will consider more detailed view of the satellite hardware architecture. + +\subsection{Details of the model} +Regarding the modelling activity, we focused first on the methodology applied to timed failure propagation described for a multi-phase system. In the starting architecture, described in Sect.~\ref{sec:aocs}, each satellite has three separate kinds of equipment: the STR (with a redundancy of 3), the ColdGasProp (with a redundancy of 3), and the IMU (with a redundancy of 2). We assume that mode transitions are initiated instantaneously (with a transition associated to a Dirac law), while events related to equipment “switching on” or rebooting are associated with a time law as follows: +\begin{itemize} +\item STR takes 30~mn, it is associated with the interval $[30,30]$ +\item IMU takes less than 10~s, it is associated with the interval $[0,0.1]$ +\item ColdGasProp takes between 5 and 10~mn, it is associated with $[5,10]$ +\end{itemize} + +We consider that these durations include all physical delays. The notification of a detected failure from Surveillance is a timed event, ranging between 0 and 10~ms. + +It is worth noting that the Synoptic (and later, the AltaRica 1.0) models that we have had access to, make practically no use of flow variables, which are variables that represent the ports’ input/output of components. This modelling style enforces that either communication are simultaneously performed both by sender and receiver either communication cannot occur at all. Moreover, This has a great influence on the empirical evaluation we performed, as undesired states are avoided by the modeller, while one of the interests of our approach resides in speeding-up the early design evaluation phase by outlining design errors and allowing an automated assessment of the model. As the design of the AOCS mode has no such flaws, we aimed at checking the invariants, in order to validate the model, and to evaluate the scalability of the approach on the former properties plus a temporal one. + +\subsection{Empirical evaluation} + +In general, real-time model-checking does not scale well on very detailed and large systems, especially when the system uses events that work on very different timescales. Nevertheless, failure propagation models can be large but not very detailed in early design phase. In this particular use case, we are able to check the smallest instances of the problem in less than 3 minutes on a typical laptop; while the most difficult problem can be checked in half an hour. + +We propose different versions of the AOCS architecture in order to appraise the complexity of the case, and the scalability of our toolchain. We apply a series of simplifications to the model, generating different benchmarks of growing complexity. The main parameters in our experiments will be the number of replicas of each equipment; and the possibility, or not, to have transient failures. +A first simplification of the model is to consider permanent failures only. Benchmarks done in this condition are denoted ``Pfail only'' (see Table~\ref{tab:results1}). This choice simplifies the model-checking problem since it discards loops in the behavior of the system that originate from the system rebooting through its ``Starting'' state. On the other hand, we can build instances that are more complex by increasing the number of equipment. For example, we can add a second kind of thruster. In Table~\ref{tab:results1}, we label each experiment with the number of different kind of thrusters used. + +For each configuration, we investigate two different kinds of properties. + +A first set of properties contains invariants on the set of states reachable by the system, like the absence of deadlocks or the property that \emph{equipment STR is always OFF when the AOCS is in Acquisition \& Safe Mode}. These are typically referred to as \emph{logical safety properties}. Both examples of properties, when true, require enumerating all the possible states of the system. Therefore, they give a good estimate of the complexity and size of the problem. Since reachability properties do not require to compute the possible transitions between two states (to compute the \emph{state graph}), it is possible to use very efficient on-the-fly techniques that are both space and time-efficient. + +Then we check an example of timing property, namely we prove a bound on the maximal time it takes for the system to reach a safe mode after a particular event. More precisely, given a duration δ, we check whether the AOCS can reach its ``Collision Avoidance'' mode in less than δ minutes after activating surveillance. We can check this kind of properties by adding an ``observer'' component that monitors the time elapsed since an event occurred and that can raise an error after a timeout. The observer adds extra behaviors to the analysis of the initial system and can therefore significantly increase its state space, especially when there is a lot of non-determinism in the system or when there are long-running activities. We observed that our use case exhibit partially these two causes of state space explosion, limiting the verification of timed properties to the one thruster benchmarks (in 640s for the ``\emph{Pfail only}'', and 44mn54s for the ``\emph{Pfail and Tfail}''), within the time-cut we set at 45mn. This can be explained by the fact that satellite systems are usually very deterministic. Indeed, operators need to plan the behavior of a satellite very precisely when they compute TCs. This is an encouraging observation for the tractability of our approach in the aerospace domain. + +\begin{table} + \centering +\begin{tabular}{|l|c|c|c|c|} + \hline + Model & states & transitions & time (s) & size (MB) \\ + \hline + 1 thruster Pfail only & 224 374 & 8345295 & 225 & 8 \\ + \hline + 1 thruster & 448 335 & 20 470 486 & & 16 \\ + \hline + 2 thrusters & 4 003 939 & 207 594 548 & & 189 \\ + \hline + 3 thrusters & - & - & - & - \\ + \hline +\end{tabular} +\caption{Empirical evaluation of state space generation, Intel Xeon @ 2.33GHz} +\label{tab:results1} +\end{table} + +Table~\ref{tab:results1} gives the results obtained with our experiments on four different configurations. We record the size of the model (in number of states and number of transitions) as well as the execution time and the memory consumed. All these results where obtained on a typical laptop with 8 GB of memory and an Intel processor. We observe that the Tina model checker scales up well on these models, failing at the biggest instance, not producing results after 45mn of run-time. These numbers give a good estimate of the complexity of checking safety properties. + +A little less than 10 years ago, a similar study~\cite{sutre09} was performed using models expressed in AltaRica 1.0 and two different model-checkers, ARC~\cite{arc} and MEC 5~\cite{mec5}. These are two tools developped specifically for the AltaRica language. Like with the experiments reported in Table~\ref{tab:results1}, ARC and MEC were used to compute the set of reachable states from an initial configuration of the system. These tools are based on symbolic methods for representing the sets of states and transitions of an AltaRica model. This is usually more efficient than enumerative techniques, such as those used by Tina. On the other hand, neither ARC or MEC take inherently into account timing constraints; whereas Tina relies on a ``symbolic'' representation of time constraints. Therefore they need to model time using an explicit clock (an integer variable) that should be updated in the model. ARC and MEC both bumped into serious limitations when scaling-up the models, even when simple invariants were checked~\cite{sutre09}. + +It is worth noting that, in our experiments, the addition of timed transitions did not increased the number of reachable states and only increased the execution time by a factor of 4. +Even if in our case study no counterexamples were generated because of the correctness of the proposed models, our toolsuite permits, in an untimed model, to compute cutsets and countreexamples showing a timed scenario where the safety property checked is violated~\cite{albore2017IMBSA}. Such couterexamples are generally not easily readable and difficult to debug. In the case of an implementation with FIACRE, it is possible to exploit relations between models representing the information required by the user on the one hand, and information produced by the tools, on the other hand to visualize in a compact view both the outcome of the model-checker and the FIACRE model, which facilitates greatly the interpretation of the analysis process~\cite{Zalila}. A possible future work would be of applying a similar approach to allow the representation of the analysis directly in the AltaRica initial model. + + +\newpage + + +%% LocalWords: ELEC Fiacre Dataflow Altarica evt Xeon + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: diff --git a/doc/Rapport post-doc/5-conclusions.tex b/doc/Rapport post-doc/5-conclusions.tex new file mode 100644 index 0000000..37a00ed --- /dev/null +++ b/doc/Rapport post-doc/5-conclusions.tex @@ -0,0 +1,131 @@ +%%%\section{Conclusion and Related Work} +\label{sec:Conclusion} + +Our work is concerned with the modelling and analysis of safety properties +in the presence of time constraints. + + +We concentrate on a +particular safety property, called \emph{loss detection convergence}, +for failures +propagation, meaning that the system applies an appropriate and timely response +(e.g. isolation) to the occurrence of a fault before the failure is +propagated and produces unwanted system behaviours. Similar problems +were addressed in~\cite{thomas2013}, where the authors describe a +process to model FDIR architecture (for use on-board satellites) that +requires to take into account failure propagation time, failure +detection time, and failure recovery time. However, these needs are not matched by +an effective way to check for safety. Our approach provides a solution to +model these timing constraints within AltaRica. We also provide an +automatic transformation from Time AltaRica models into one of the +input formats of Tina. We show that two interesting +problems---computing ``timed cuts'' and bounding the convergence +latency of a node---can be reduced to a decidable model-checking +problem. + +Several works have combined model-checking and AltaRica, the +archetypal example being the MEC tool~\cite{griffault2004mec} that was +developed at the same time than the language. More recently, Bozzano +et al~\cite{bozzano2012} have defined a transformation from AltaRica +Dataflow to the symbolic model-checker NuSMV. While this tool does not +support complex timing constraints, it offers some support for Dirac +laws (and implicit priorities) by encoding an ad-hoc scheduler. The +use of symbolic model-checking techniques is interesting in the case +of models with a strong combinatorial blow up, like for instance model +HYDRO of Sect.~\ref{sec:sect4}. Nonetheless, even though Tina also +includes BDD-based tools, no approaches allow to combine the advantages +of both realtime and symbolic model-checking techniques. + +Realtime techniques are central to our approach. We define an +extension of AltaRica where timing constraints can be declared using +{temporal laws} of the form \code{law (evt) = "[a,b]"}, with a +semantics inspired by Time Petri nets. As a result, we can apply on +AltaRica several state space abstractions techniques that have been +developped for ``timed models'', such as the use of DBM and state +classes~\cite{berthomieu2004tool}. In a different way, Cassez et +al.~\cite{pagetti2004} have proposed an extension of AltaRica with +explicit ``clock variables'', inspired by Timed Automata, where clocks +are real-valued flow variables that can be used inside the guards of +events. +%% +% (Which means that there are restrictions on the type of equations +% one can use in the \code{assert} declaration of a node.) +%% +% They also define an algorithm to compile this extension into +% Uppaal~\cite{larsen1997uppaal}. +Their work is mainly focused on the verification of behavioural +properties and centers on the encoding of urgency and priorities +between events, two notions that are naturally offered in +Fiacre. Also, our extension is less invasive. If we ignore the +\code{extern} declaration then we obtain valid AltaRica code. More +research is still needed to further the comparison between these two +approaches in the context of safety assessments. + +Aside from these works on AltaRica, we can also cite recent works that +combine failure propagation analysis and timing constraints, such +as~\cite{bittner2016}. This work defines an automatic method for +synthesising \emph{Timed Failure Propagation Graphs} (TFPG), that is +an extension of the notion of cut-sets including information on the +date of events. TFPG provide a condensed representation that is easier +to use than sets of timed cuts.Therefore, it would be interesting to +use this format in our case. + +For future work, we plan to adapt our translation to a new version of +the AltaRica language---called AltaRica 3.0, or OpenAltaRica---that +imposes less restrictions on the computation of flow variables. We +also want to apply our approach to more complex industrial use cases, +involving reconfiguration time besides failure detection and +isolation; or even systems with humans and reaction time in the +loop. + +% More generally, the main purpose of our project is to build on +% the results of use cases in order to propose a set of modelling +% guidelines for taking into account time in failure propagation +% analysis. + + + +% AltaRica 3.0 still relies on propagation based variable update, but +% the order in which this +% propagation takes place in determined at execution time, in other +% words, a fix-point is computed. This update scheme extends +% significantly the expressivity of the language, making possible to +% handle looped systems, i.e. systems in which variables depend of +% each other in a circular way, as the order of the updates is left +% free to the modeller. } + + +% Actual industrial systems embed several elements of complexity, that +% affects the design phase, caused by the diversity of technical issues +% and evaluation criteria coming from different viewpoints. + +% % +% Nevertheless, defining and verifying these properties is critical for +% embedded and real-time systems. In particular, time information, as +% delays or durations, are the properties that are central in real-time +% systems design and verification: in fact, temporal aspects can be the +% cause of missed failure detections or undesired reactions to (delayed) +% failure propagation. To be able to perform a safety analysis on the +% temporal properties allows to create systems that will operate as +% intended in a real-world environment. +% % Additional benefits from timed and temporal models are the ability +% % to perform formal verification in early development stages, using +% % automated techniques as model-checking. + + + +The use of timed Altarica will help system designers to verify critical properties when time-bounded reactions are required. On the application side, it is central to use formal methods, e.g. model-checking, to validate properly formalized specifications. Forcing the designer to produce early well formed models during the specification phase yields to have the specifications formalised and pinned down for the next development phases. Then, the validation of those specifications in the model allows to identify behavioral inconsistencies. Espacially, such inconsistencies are difficult to identify in a classical, purely paper-based, specification process. Last, formal verification proves that none of the possible execution scenarios violates the system properties. Such approaches are useful not only for validating an architecture or FDIR strategy once defined, but also for tuning its parameters during the conception phase. Results from the early V\&V of the on-board processes and FDIR design can be fed back into the requirements analysis phase. The contribution of proper (formal) analysis tools to the complex system designs helps in reducing the specification phase, and the early validation of requirements and models. Such extended V\&V toolbox will eventually consent to reduce the time cost of large projects, helping the development of new spacecraft technologies. + + +\section{Future Work} + + + + + +%% LocalWords: Dataflow OpenAltaRica + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: diff --git a/doc/Rapport post-doc/IMBSA-paper.tex b/doc/Rapport post-doc/IMBSA-paper.tex new file mode 100644 index 0000000..3d625ee --- /dev/null +++ b/doc/Rapport post-doc/IMBSA-paper.tex @@ -0,0 +1,64 @@ +\documentclass{llncs} + +%\usepackage{graphicx} +% +\begin{document} + + +\title{Formal Safety Verification of Temporal Model Properties via Model-Checking Mots clés Titre à trouver + +\author{Alexandre Albore, Silvano Dal Zillo, Guillaume Infantes, Christel Seguin, Pierre Virelizier} + +\institute{alexandre.albore@irt-saintexupery.com , IRT Saint Exupéry, +118, route de Narbonne - CS 44248 +31432 Toulouse cedex 4 (France) } +\maketitle + +\begin{abstract} + +Abstract is here. + +\end{abstract} + +\section{Introduction}\label{sec:Introduction} + +Ce qu’on présente : méthode et chaine outillée pour la vérification formelle à travers model-checking de propriétés temporelles dans des modèles avec des retards dans la transmission des messages d’erreur. Par exemple, s’assurer de la fiabilité d’une fonction d’alarme quand des délais affectent les temps de la propagation des pannes. Traiter des modèles temporisés et en valider les propriétés temporelles de façon formelle est un enjeu fondamental dans le domaine de la safety. +. : cf. PV +Mo + +\section{Study case}\label{sec:Others} + + Élément de retard avec Dirac + Propriétés qu’on veut vérifier (temporisation et délai sur les messages. Hypothèses sur les délais pour les pertes dans la chaîne précédente, c-à-d s’assurer de la fiabilité de la fonction d’alarme) ; on sait que si on a un retard différent sur les lignes, l’alarme n’est pas garanti, e.g. r1 + r2 <> r2 + r3. + + \section{Altarica and Fiacre} + Tina / Fiacre et Petri temporisé et les propriétés que ça rajoute\\ + Altarica vu à travers l’exemple\\ + Traduction Altarica -> Fiacre + + \section{Empirical evaluation - Fiacre} + Example sans délais (delta 0) : loss -> alarme et $F4_{loss}$\\ + Example avec délais (delta N) : loss -> !alarme et $!F4_{loss}$\\ + Example avec délais non-déterministe (pourrait identifier le temps minimum) + +\section{Conclusion}\label{sec:Conclusion} + +État de l’art (model-checking temporisé, model-checking temporisé paramétrique, …) +Conclusion : plus-value (une suite outillée, fournir un cadre unifié d’outils) + + + +\section*{Acknowledgments}\label{sec:Acknowledgments} + +Authors would like to thank YYYYY. + +\begin{thebibliography}{1} + +\bibitem{Einstein} +A. Einstein, On the movement of small particles suspended in stationary liquids required by the molecular-kinetic theory of heat, Annalen der Physik 17, pp. 549-560, 1905. + +\end{thebibliography} + +\end{document} + + diff --git a/doc/Rapport post-doc/algos/function.fcr b/doc/Rapport post-doc/algos/function.fcr new file mode 100644 index 0000000..46e78ec --- /dev/null +++ b/doc/Rapport post-doc/algos/function.fcr @@ -0,0 +1,17 @@ +type FState is union NOMINAL | LOST | ERROR end +type FailureType is union Err | Loss | Ok end +type Flows is record I:FailureType, O:FailureType end + +function update(S : FState, env : Flows) : Flows is + var f : Flows := {I=env.I, O=env.O} + begin + f.O := (S = NOMINAL ? f.I : (S = LOST ? Loss : Err)); + return f + end + +process Function(&S : FState, &env : Flows) is + states s0 + from s0 select + on (S != LOST); S := LOST; env := update(S, env); loop + [] on (S = NOMINAL); S := ERROR; env := update(S, env); loop + end \ No newline at end of file diff --git a/doc/Rapport post-doc/algos/function2.alt b/doc/Rapport post-doc/algos/function2.alt new file mode 100644 index 0000000..6cf43fb --- /dev/null +++ b/doc/Rapport post-doc/algos/function2.alt @@ -0,0 +1,12 @@ +domain FState = {NOMINAL, LOST, ERROR} ; +domain FailureType = {Err, Loss, Ok} ; + +node Function + flow I : FailureType : in ; O : FailureType : out ; + state S : FState ; + event fail_loss, fail_err ; + init S := NOMINAL ; + trans S != LOST |- fail_loss -> S := LOST ; + S = NOMINAL |- fail_err -> S := ERROR ; + assert O = case { S = NOMINAL : I, S = LOST : Loss, else Err } ; +edon \ No newline at end of file diff --git a/doc/Rapport post-doc/algos/function2.fcr b/doc/Rapport post-doc/algos/function2.fcr new file mode 100644 index 0000000..d3f5a12 --- /dev/null +++ b/doc/Rapport post-doc/algos/function2.fcr @@ -0,0 +1 @@ + diff --git a/doc/Rapport post-doc/algos/pre.alt b/doc/Rapport post-doc/algos/pre.alt new file mode 100644 index 0000000..f326cb1 --- /dev/null +++ b/doc/Rapport post-doc/algos/pre.alt @@ -0,0 +1,12 @@ +domain BType = {Empty, Full} ; +node Pre + flow I : FailureType : in; O: FailureType : out; + state Stored, Delayed : FailureType, S : BType; + event pre_read, pre_wait; + init Stored := Ok, Delayed := Ok, S := Empty; + trans + (Stored != I) & (S = Empty) |- pre_read -> Stored := I, S = Full; + (S = Full) |- pre_wait -> Delayed := Stored, S = Empty; + assert O = Delayed; + extern law (pre_read) = "[0,0]"; law (pre_wait) = "[a,b]"; +edon diff --git a/doc/Rapport post-doc/algos/pre.fcr b/doc/Rapport post-doc/algos/pre.fcr new file mode 100644 index 0000000..7f9c38a --- /dev/null +++ b/doc/Rapport post-doc/algos/pre.fcr @@ -0,0 +1,8 @@ +type BType is union Empty | Full end + +process Pre(&Stored, &Delayed : FailureType, S : BType, &env : Flows) is + states s0 + from s0 select + on (Stored != env.I and S = Empty); wait [0,0]; Stored := I; ... + [] on (S = Full); wait [a,b]; Delayed := Stored; S := Empty; ... + end \ No newline at end of file diff --git a/doc/Rapport post-doc/algos/pre2.fcr b/doc/Rapport post-doc/algos/pre2.fcr new file mode 100644 index 0000000..5a9a072 --- /dev/null +++ b/doc/Rapport post-doc/algos/pre2.fcr @@ -0,0 +1,22 @@ +process Pre(&Stored, &Delayed : FailureType, S : BType, &env : Flows) is + states s0 + from s0 select + on (Stored != env.I and S = Empty); wait [0,0]; Stored := env.I; $\ldots$ + [] on (S = Full); wait [a,b]; Delayed := Stored; S := Empty; $\ldots$ + end + +process delay[go : in FailureType](&O : FailureType) is + states sEmpty, sFull + var delayed : FailureType := Ok + from sEmpty go?delayed; to sFull + from sFull wait [a,b]; O := delayed; to sEmpty + +process front[p,q : out FailureType](&I : FailureType) is + states s + var stored : FailureType := Ok + from s on (I != stored); stored := I; select p!I [] q!I end; loop + +component Pre_2(&I, &O: FailureType) is + port go1, go2 : FailureType in [0,0] + priority go1 > go2 + par * in front[go1,go2](&I) || delay[go1](&O) || delay[go2](&O) end \ No newline at end of file diff --git a/doc/Rapport post-doc/aliascnt.sty b/doc/Rapport post-doc/aliascnt.sty new file mode 100644 index 0000000..452aa0e --- /dev/null +++ b/doc/Rapport post-doc/aliascnt.sty @@ -0,0 +1,88 @@ +%% +%% This is file `aliascnt.sty', +%% generated with the docstrip utility. +%% +%% The original source files were: +%% +%% aliascnt.dtx (with options: `package') +%% +%% This is a generated file. +%% +%% Project: aliascnt +%% Version: 2009/09/08 v1.3 +%% +%% Copyright (C) 2006, 2009 by +%% Heiko Oberdiek +%% +%% This work may be distributed and/or modified under the +%% conditions of the LaTeX Project Public License, either +%% version 1.3c of this license or (at your option) any later +%% version. This version of this license is in +%% http://www.latex-project.org/lppl/lppl-1-3c.txt +%% and the latest version of this license is in +%% http://www.latex-project.org/lppl.txt +%% and version 1.3 or later is part of all distributions of +%% LaTeX version 2005/12/01 or later. +%% +%% This work has the LPPL maintenance status "maintained". +%% +%% This Current Maintainer of this work is Heiko Oberdiek. +%% +%% This work consists of the main source file aliascnt.dtx +%% and the derived files +%% aliascnt.sty, aliascnt.pdf, aliascnt.ins, aliascnt.drv. +%% +\NeedsTeXFormat{LaTeX2e} +\ProvidesPackage{aliascnt}% + [2009/09/08 v1.3 Alias counter (HO)]% +\newcommand*{\newaliascnt}[2]{% + \begingroup + \def\AC@glet##1{% + \global\expandafter\let\csname##1#1\expandafter\endcsname + \csname##1#2\endcsname + }% + \@ifundefined{c@#2}{% + \@nocounterr{#2}% + }{% + \expandafter\@ifdefinable\csname c@#1\endcsname{% + \AC@glet{c@}% + \AC@glet{the}% + \AC@glet{theH}% + \AC@glet{p@}% + \expandafter\gdef\csname AC@cnt@#1\endcsname{#2}% + \expandafter\gdef\csname cl@#1\expandafter\endcsname + \expandafter{\csname cl@#2\endcsname}% + }% + }% + \endgroup +} +\newcommand*{\aliascntresetthe}[1]{% + \@ifundefined{AC@cnt@#1}{% + \PackageError{aliascnt}{% + `#1' is not an alias counter% + }\@ehc + }{% + \expandafter\let\csname the#1\expandafter\endcsname + \csname the\csname AC@cnt@#1\endcsname\endcsname + }% +} +\newcommand*{\AC@findrootcnt}[1]{% + \@ifundefined{AC@cnt@#1}{% + #1% + }{% + \expandafter\AC@findrootcnt\csname AC@cnt@#1\endcsname + }% +} +\def\AC@patch#1{% + \expandafter\let\csname AC@org@#1reset\expandafter\endcsname + \csname @#1reset\endcsname + \expandafter\def\csname @#1reset\endcsname##1##2{% + \csname AC@org@#1reset\endcsname{##1}{\AC@findrootcnt{##2}}% + }% +} +\RequirePackage{remreset} +\AC@patch{addto} +\AC@patch{removefrom} +\endinput +%% +%% End of file `aliascnt.sty'. diff --git a/doc/Rapport post-doc/altarica-diagrams.tex b/doc/Rapport post-doc/altarica-diagrams.tex new file mode 100644 index 0000000..093dd5b --- /dev/null +++ b/doc/Rapport post-doc/altarica-diagrams.tex @@ -0,0 +1,32 @@ +\documentclass[tikz]{standalone} + +\usepackage{tikz} +\usetikzlibrary{arrows,shapes,shapes.geometric,decorations,automata,shadows} + +\tikzstyle{edge}=[draw,thick,->] \tikzset{state/.style={draw, text + centered, thick, rectangle split, rectangle split parts=2, rounded + corners,fill=blue!10}} + +\newcommand{\STATE}[2]{\makebox[5em]{\vphantom{I}{\ttfamily #1}}\nodepart{second} \makebox[4em]{\vphantom{I}{\ttfamily #2}}} + + +\begin{document} +\begin{tikzpicture}[scale=1.25, + initial text={}, + initial distance=2em, + every initial by arrow/.style={thick,*->}] + \node [state,initial] (s0) at (0,-1) {\STATE{NOMINAL}{O = I}}; + \node [state] (s1) at (4,0) {\STATE{LOST}{O = Loss}}; + \node [state] (s2) at (4,-2) {\STATE{ERROR}{O = Err}}; + + \path[edge] (s0) edge[bend left] node[below, yshift=-10pt] + {{\ttfamily fail\_loss}} (s1); + \path[edge] (s0) edge[bend right] node[right, yshift=5pt] {{\ttfamily fail\_err}} (s2); + \path[edge] (s2) edge node[right] {{\ttfamily fail\_loss}} (s1); +\end{tikzpicture} +\end{document} + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: t +%%% End: diff --git a/doc/Rapport post-doc/altarica-function.tex b/doc/Rapport post-doc/altarica-function.tex new file mode 100644 index 0000000..fa38db7 --- /dev/null +++ b/doc/Rapport post-doc/altarica-function.tex @@ -0,0 +1,24 @@ +\documentclass[tikz]{standalone} + +\usepackage{tikz} +\usetikzlibrary{arrows,shapes,positioning,decorations,decorations.markings,shadows} + +\tikzstyle{block} = [rectangle, draw, fill=white, text centered, +text width = 3em, minimum height = 1.5em] +\tikzstyle{point} = [circle, fill=green!80, minimum height=0.5em] +\tikzstyle{line} = [draw, -latex'] + +\begin{document} +\begin{tikzpicture}[] + \node [block] (F) at (1.5, 0) {}; + \node [point] at (1.5, 0) {}; + + \node [] (L) at (0,0) {{\ttfamily I}}; + \node [] (R) at (3,0) {{\ttfamily O}}; + + \node [above of=F, node distance=1.5em] {{\ttfamily Function}}; + + \path[line] (F) -- (R); + \path[line] (L) -- (F); +\end{tikzpicture} +\end{document} diff --git a/doc/Rapport post-doc/app.tex b/doc/Rapport post-doc/app.tex new file mode 100644 index 0000000..8e496c8 --- /dev/null +++ b/doc/Rapport post-doc/app.tex @@ -0,0 +1,588 @@ +\section{Interpretation of AltaRica in Fiacre} +\lstset{ keywordstyle=\bfseries, + % keywordstyle={[2]\itshape}, + keywordstyle=\color{bluekeywords}, + basewidth=0.94ex, + showstringspaces=false, + emptylines=1, + aboveskip=4pt,belowskip=4pt, + mathescape=true, + texcl=true, + escapechar=@, + numberblanklines=false} + \newcommand{\sem}[1]{\llbracket{#1}\rrbracket} + +This appendix can be safely ignored and is not necessary to understand +the approach described in the report. Its main purpose is to give a +precise definition of the encoding from AltaRica to Fiacre that is +only roughly described in Sect.~\ref{sec:sect3}. + +We give a more precise definition of our encoding from AltaRica +Dataflow to Fiacre. We base our definition on a simplified grammar for +AltaRica Dataflow, using the Cecilia OCAS syntax, and a ``semantics +function'' (denoted $\sem{\,}$) to translate an AltaRica expression +into Fiacre. The encoding uses an environment, $\sigma$, to map event +identifiers (\code{evt}) to their timing constraints (defined in the +\code{extern} heading). We omit this environment when it is obvious +from the context. + +We describe the grammar of the AltaRica language using a variant of +Extended Bachus Naur Form (EBNF). The EBNF describes a set of +production rules of the form ``\code{symb ::= expr}'', meaning that +the nonterminal symbol \code{symb} represents anything that can be +generated by the EBNF expression \code{expr}. An expression +\code{expr} may be one of the following: a terminal symbol or keyword, +between quotes (e.g., \code{'event'}); a nonterminal symbol; an +optional expression, written ``\code{[ expr0 ]}''; a choice between +two expressions, written ``\code{expr1} $\,\mid\,$ \code{expr2}''; the +iterative concatenation of one or more expressions, with successive +occurrences being separated by a given symbol \code{s}, written +``\code{(expr s)*}''. + + +\subsection*{Types} +\label{sec:types} + +AltaRica base types include ``Boolean'' and Integers. We do not +consider floating point number in our translation; even though real +numbers are useful to declare probabilities, floating point variables +do not fit well with an enumerative model-checking approach. The +language also provides enumeration types, called \emph{domains}, that +defines sets of symbolic constants that can be used with state +variables. + +\begin{lstlisting}[language=BNF] +Type ::= 'Boolean' | 'Integer' | Ident +Domain ::= 'domain' Ident '{' (Ident ',')* '}' +\end{lstlisting} + +Fiacre supports a boolean type \code{bool}, with the same primitive +operators than AltaRica, equality (\code{=}) and inequality +(\code{<>}), and a ternary conditional operator. The numeric types of +Fiacre include the type \code{int} of all integers and the the type +\code{nat} of non negative integers. As we stated in +Sect.~\ref{sec:sect3}, domains can be directly encoded using union +types in Fiacre. + +\begin{lstlisting}[language=BNF] +[[Boolean]] = bool [[Integer]] = int [[Ident]] = Ident +[[domain IType {I1 , ..., In}]] = type IType is union I1 | ... | In end ; +\end{lstlisting} + +The fact that we can directly reuse the same type identifier in the +two languages means that we can directly reuse AltaRica type +declarations in Fiacre. Indeed, a type declaration of the form +\code{V1 : T1, ..., Vn : Tn} is encoded in Fiacre as follows: +% +\lstinline[language=BNF]{V1 : [[T1]], ..., Vn : [[Tn]]} + +Note that a limitation of Fiacre type declarations is that all type +constructors must be different, therefore we assume that the constants +used in different domains are always distinct. (This restriction +could be lifted by renaming constants using some information from the +type checker, but this has no effects on the expressiveness of our +approach.) + +\subsection*{Instructions} +\label{sec:instructions} + +Instructions are used to described the actions (postcondition) of +transitions and assertions. There are fundamentally four instructions: +skip, assignments, if-then instructions and composition. All the +possible instructions in AltaRica can be rewritten using only these +four fundamental instructions. A notable example of instruction +missing in this short list is the switch statement (that can be +encoded using nested conditionals). Fiacre provides an equivalent +\code{case}-statement that can be used to do traditional +pattern-matching. + +\begin{lstlisting}[language=BNF] +Instr ::= 'skip' | V ':=' Expr | 'if' Expr 'then' Instr | '{' (Instr)* '} +\end{lstlisting} + +Expressions, \code{Expr}, are built using the variables, constants and +the usual arithmetic operators. The syntax of expressions is exactly +the same as in Fiacre, so we have +% +\lstinline[language=BNF]{[[Expr]] = Expr}. + +The equivalent of instructions in Fiacre is called statement. The +\code{skip} instruction is a ``neutral element''; it describes the +instruction that does nothing. Fiacre has an equivalent notion with +the statement \code{null}. Assignments and conditionals are also +present in Fiacre, with the same semantics. The main difference is +that we do not enforce any differences between flow and state +variables. + +\begin{lstlisting}[language=BNF] +[[skip]] = null +[[V := Expr]] = V := [[Expr]] +[[if Expr then Instr]] = if [[Expr]] then [[Instr]] end +[[{I1 ... In}]] = [[I1]] ; ... ; [[In]] +\end{lstlisting} + +The interpretation of AltaRica instructions is straightforward. The +main discrepancy is with composition. For most practical purposes, +composition in AltaRica can be encoded using sequential +composition. In the case where different statements in a composition +update the same variable, it could be necessary to introduce temporary +variables, but this can be already enforced in the original AltaRica +instruction. For example, the composition \code{\{(X := Y) (Y := + X)\}}, that can be used to swap the values of two variables in +AltaRica, should be replaced by the instruction \code{\{(TEMP := X) (X + := Y) (Y := TEMP)\}}. + +\subsection*{Nodes} + +An AltaRica model is essentially a collection of node declarations. A +node is made of three parts: declaration of state variables, flow +variables and events; declaration of transitions; and finally +assertions. + +\begin{lstlisting}[language=BNF] +Node ::= 'node' Ident Flow State Event Init Trans Assert [Extern] +Flow ::= 'flow' (Ident ':' Expr ':' ('in' | 'out') ',')* ';' +State ::= 'state' (Ident ':' TypIdent ',')* ';' +Event ::= (Ident ',')* ';' +Init ::= 'init' Expr ';' +Trans ::= 'trans' (Expr v- Ident -> Expr ';')* +Assert ::= 'assert' Expr ';' +\end{lstlisting} + +In the following, we assume that we want to encode a node \F{} with +flow variables declaration \code{flow V1 : T1, ..., Vk : Tk;} and +state variables declaration \code{state S1 : I1, ..., Sn : In;}. Our +encoding makes use of a Fiacre record type, \code{Flows}, defined as +follows. + +\begin{lstlisting}[language=BNF,mathescape=true] +type Flows is record V1 : [[T1]], ..., Vk : [[Tk]] end +\end{lstlisting} + +The type \code{Flows} is used to define a function computing the +effect of assertions on the flow variables. The behaviour of +assertions is one of the main differences between dialects of +AltaRica. The case of AltaRica Dataflow is the simplest since, by +definition, there should be a fixed order (computable at compile time) +in which to evaluate the assignments defined in the \code{assert} +heading. In this case, if the node declares an assert expressions +\code{assert exp;} then we assume that the Fiacre function +\code{update} is declared as follows, where \code{((exp))} is the +Fiacre expression $\llbracket$\code{exp}$\rrbracket$ in which every +occurrence of flow variables, \code{Vi}, are replaced with a record +field access, \code{f.Vi}. + +\begin{lstlisting}[language=BNF,mathescape=true] +function update(S1 : I1, ..., Sn : In, env : Flows) : Flows is + var f : Flows := env + begin + ((exp)) + return f + end +\end{lstlisting} + +Other dialects of AltaRica may require a fixpoint computation, or at +least a recursive evaluation of the \code{assert} expression. This +different semantics could be encoded in Fiacre as well. Indeed Fiacre +functions can be recursively defined. For better performances, it is +also possible to implement the computation of assertions in an +external library and to import it in Fiacre using Foreign Function +Interfaces. + +The definition of the node may also contain timing constraints +declared using an \code{extern} clause. A timing constraint is a +(time) interval of the form \code{[a, b]}, \code{]a, b]}, \code{[a, + b[}, or \code{]a, b[}. An interval of the form \code{[a, ...[} is +used to denote an unbounded interval (that is a $\infty$-bound). + +\begin{lstlisting}[language=BNF] +Extern ::= 'extern' ('law' '(' Ident ')' '=' '"' Time '"' ';')* +Time ::= Left ',' Right +Left ::= '[' Int | '[' Int +Right ::= Int ']' | Int '[' | '...' '[' +\end{lstlisting} + +When there is a declaration \code{extern law(evt) = "Time";} in the +definition of the node \F{}, we assume that the environment $\sigma$ +is such that $\sigma$(\code{evt}) = \code{Time}. If an event is not +declared in the \code{extern} heading then we can safely assume that it +is associated with the time constraint \code{[0, ...[}. + +Equipped with all these additional definitions, it is possible to +encode every transition declared in \F{} into a Fiacre statement. In +particular, each transition of the form +%% +\lstinline[language=Altarica]{g |-evt-> Exp ;}. +%% +in the AltaRica code can be encoded into Fiacre as a sequence of a +conditional (a test on the guard \code{g}); followed by an action +(evaluation of the expression $\llbracket$\code{exp}$\rrbracket$); +finished by the evaluation of assertions. In this example we assume +that the transition \code{evt} is associated with the time interval +$I$, that is $\sigma(\text{\code{env}}) = \text{I}$. +%% +\begin{lstlisting}[language=BNF,mathescape=true] +[[evt]] = #evt; wait $\text{I}$; on(g); [[Exp]]; env := update(S1, ..., Sn, env); loop +\end{lstlisting} + +Our encoding makes use of some assumptions that were not introduced +previously. Like in the example of Sect.~\ref{sec:sect3}, we encode a +node as a Fiacre process with a unique state. The statement +\code{loop} is used in Fiacre to declare that the target (the +destination state) of the transition is the same as its source. The +expression \verb+#+\code{evt} is a way to associate a ``tag'' with a +Fiacre transition. Tags give an alternative way to name transitions in +a temporal logic formula (for model-checking) and when we print or +simulate a counterexample. In a nutshell, we use tags as a simple +mechanism for traceability between the AltaRica and Fiacre code. + +With all the definitions introduced in this section, the encoding of +node \F{}, with transitions \code{evt1, ..., evtk}, boils down to a +single Fiacre process. To conclude, we simply need to create a +top-level component that creates an instance of this process and +initializes the state and flow variables. In the following listing, we +assume that \code{Expi} corresponds to the (AltaRica) expression +associated with the state variables \code{Si} in the \code{init} +heading of \F{}. In this code, we use the \code{init} declaration of +Fiacre that allows us to initialize the value of the flow variables in +the initial state. + +%,float=hbt,frame=single,captionpos=b,caption=\protect{Code +%skeleton for the interpreation of the Node \F{} in Fiacre}] +\begin{lstlisting}[language=BNF] +type Flows is record V1 : [[T1]], ..., Vk : [[Tk]] end + +function update(S1 : I1, ..., Sn : In, env : Flows) : Flows is + var f : Flows := env + begin + ((exp)) + return f + end + +process F(&S1 : I1, ..., &Sn : In, &env : Flows) is + states s0 + + init + env := update(S1, ..., Sn, env); + to s0 + + from s0 select + [[evt1]] [] ... [] [[evtk]] + end + +component Main is + var env : Flows, + S1 : I1 := [[Exp1]], + ..., + Sn : In := [[Expn]] + + par F(S1, ..., Sn, env) end +\end{lstlisting} + + + + +\section{Method and translation}\label{sec:sectB} + +\subsection{Time Petri Nets} +Petri Nets are bi-partite graphs with two classes of nodes: places and transitions. +Time Petri Nets are en extension to classical Petri nets that include time features, % TODO Cite Merlin +namely two real numbers, $a$ and $b$, with $a < b$, that label each transition and indicate the time interval a transition is active, being \emph{de facto} a temporal guard. + + \begin{definition}[Time Petri Nets]\label{def:TPN} + A time Petri net (TPN) is a tuple $\langle P, T, B, F, M_0, \tau \rangle $ where: + \begin{itemize} + \item $P$ is a finite nonempty set of places $p_i$; + \item $T$ is a finite nonempty set of transitions $t_i$; + \item $F$ is the flow relation + $ F : P \times T \to P$ + \item $M_0$ is the initial marking function + $ M_0 :P \to \mathbb{N} $ + \item $\tau$ is a mapping called static (firing) interval for transitions + $ \tau : T \to \mathbb{R}^+_0 \times (\mathbb{R}^+_0 \cup \infty) $ + \end{itemize} + + +% \item $B$ is the backward incidence function +%$ B:T\times P \to \mathbb{N}$ +%\item $F$ is the forward incidence function +%$ F:T\times P \to P\times T $ +%% However, as new markings via a transition t_i are given by +%% M'(p) = M(p) - B(t_i,p) + F(t_i,p) for all p +% The function F resumes and simplifies this transition, associating to a set of places and enabled transitions (i.e. a state), a set of places and enabled transitions. +% The current marking $M$ of a TPN is obtained from the transitions history $t_1, \ldots t_n$, s.t. $ M = t_n \circ t_1(M_0)$, +% with the new marking $M'$, calculated from a transition $t$ and a marking $M$ is given by +% M' = M - prec(p) + post(p) + \end{definition} +For reference, the tuple $\langle P, T, F, M_0\rangle $ identifies a Petri net. + +A transition $t \in T$ is \emph{fireable} when all its input places have at least one token; for sake of simplicity, we do not consider here weights on transitions, as the result is similar, with just a change in the marking calculation. +The flow relation then associates to the number of tokens in a place (which we call $w: P \to \mathbb{N}$ a function of the place) and a fireable transition, the tokens in the target place. + + +\subsubsection{States in a TPN} + +The dynamic aspects of Petri net model are denoted by +markings which are assignments of tokens +to the places of a Petri net. The execution is then derived from the number and emplacements of tokens. + +Given the definition above, a state in a TPN is given by the pair $(M,I)$, where +the marking $ M = \{m = w(p)\,|\, p \in P\}$ can be seen as a vector of markings, +and +% the temporal constraints on each active transition $TC= (\theta_{min}, \theta_{max})$ +the firing interval set is $I = \{\tau(t)\:|\:t\in T\}$, which can be seen as a vector of firing intervals for the fireable transitions~\cite{berthomieu1991TPN}. + + + +Over TPN states and transitions between them, it is possible to define an \emph{extended state graph}\cite{yao}, +which root corresponds to the state coming from the initial marking and fireable transitions +% +The new markings are computed as usual, by applying $F$ on the marking of the current state, and, +similarly, the new firing interval is computed consequently, for a more detailed description refer to \cite{berthomieu1991TPN}. +Thus, the transition rules permit to compute states and state reachability. + +% The reachable states from a state $S = (M,I)$ +% are the states $S'$ such that, $\forall t \in I$ (the transitions fireable) at time $\theta$ leading to state $S'$. + +\subsection{From AltaRica to Tina} +The underlying mathematical model of the AltaRica language is a Guarded Transition System (GTS), an automaton that generalises Reliability Block Diagrams, Markov chains and Stochastic Petri nets~\cite{rau08}. In GTS, states are represented by value assignment to variables, while the states transitions are triggered by events, that change the variables value. Synchronisation between events (habitually asynchronous) is produced by introducing a new event. + +Given that it is always possible to obtain a flattened model from a +composition of interconnected AltaRica nodes, it is then possible to +interpret a (general) AltaRica model by using the GTS model encoding. +Our translation approach relies on Extended Timed Guarded Transition System (ETGTS), an extension of the GTS of AltaRica opportunely enriched to include timed guards. + +Expressing durations over event and non-deterministic transitions triggered by temporal guards, fall out of the AltaRica Dataflow expressiveness and thus cannot be captured nor analysed by its associated tool. %which can treat time as a set of delay assignment, i.e. with a fixed delay associated to each transition. +So, we enriching the syntax of AltaRica Dataflow to model temporal guarded transitions by adding a new event law, as defined in Def.~\ref{def:ETGTS}. + + +\begin{comment} +%%%%start comment +\begin{definition}[ETGTS]\label{def:ETGTS} + An Extended Timed Guarded Transition System is a tuple $\langle S, s_0, E, T, \tau \rangle $ where: + \begin{itemize} + \item $S$ is a set of states; + \item $s_0 \in S$ is the initial state; + \item $E$ is a set of event symbols; + \item $T$ is a set of transitions s.t. $T \subseteq S \times E \times S$. + \item $\tau$ is the delay relation, $\tau: E \to \mathbb{R}^+ \times (\mathbb{R}^+ \cup \infty)$, assigning a minimal and a maximal delay to the transitions bound to event $e$. + \end{itemize} + A transition $t \in T: (s, e, s')$ associates a state $s'$, to a state $s$ by executing the event $e$ in $s$, after a delay in the interval $[\delta_{min}, \delta_{max}]$ given by $\tau(e)$. + + A \emph{run} $\rho$ of a timed Transition System is a sequence of pairs event-time from the initial state $s_0$: + \begin{align*} + \rho &= \{ (e_1,\delta_1), \ldots, (e_n,\delta_n) \} \; + \text{s.t. } \forall i \;\delta_i \in \tau(e_i), \text{ and }\\ + &s_0 \xrightarrow{t_1} s_1 \xrightarrow{t_2}\cdots \xrightarrow{t_n} s_n, \text{ with } \forall i \;t_i = (s_{i-1}, e_i, s_i) \in T + \end{align*} +\end{definition} + + +\TODO{TGTS for us, as delta can be used, but not necessary} + +\begin{definition}[GTS]\label{def:GTS} + A GTS is a tuple $\langle V,E,T, A, \nu \rangle $ where: + \begin{itemize} + \item $V$ is a set of variables, divided in two sets of variables: the set $S$ of \emph{state variables}, and $F$ of \emph{flow variables} s.t. $V = S \cup F.$ + \item $E$ is a set of event symbols + \item $T$ is a set of transitions, s.t. $t \equiv (\gamma, e, \varphi) \in T$ with $e \in E$, $\gamma$ and $\varphi$ are Boolean expressions built over $V$ called \emph{guard} and \emph{post-condition} resp. A transition $t$ applies in a state $s \in 2^{|V|}$ s.t. $s \models \gamma$, resulting in a state $s' \models \varphi$. + \item $A$ is the set of \emph{assertions}, i.e. Boolean expressions built over $V$. Assertions are concatenated to each transition, in order to update flow variables, \TODO{modelling the failure propagation. } + \item $\nu$ is the initial assignment of variables of $V$. + \end{itemize} + \end{definition} + +\TODO{1) define the semantics of a transition, i.e. how to pass from a state $\sigma$ to a state $\rho$. 2) define a trace in the timed graph, with events labelled by the firing time, i.e. a plan for Tina} + +A GTS is a (possibly infinite) graph $\Gamma = (\Sigma, \Theta)$, where $\Sigma$ is a set of nodes given by all the possible variable assignments in $V$, and $\Theta$ is a set of guarded transitions $(\sigma, e, \rho)$, where $\sigma, \rho \in \Sigma$ and $e \in E$. + +blocks and processes, from the GTS to the Petri Net (states, places, tokens). + +\begin{definition}[Temporal GTS]\label{TTGTS} +\TODO{Timed GTS already exist, we can use another name to avoid confusion} +A Temporal Guarded Transition System is a tuple $\langle V,E,T, A,\nu, \Delta \rangle$ where + \begin{itemize} + \item $\langle V,E,T, A, \nu \rangle $ is a GTS defined as in Def.~\ref{def:GTS} + \item $\Delta$ is a delay function s.t. $\Delta: E \to \mathbb{R}^+ \times \mathbb{R}^+$, assigning an initial and a final firing time to the transitions bound to event $e$. + \end{itemize} +\end{definition} + + +\TODO{Next paragraph is possibly untrue, as TGTS can be modified such to include delay \emph{functions} as we did with Fiacre and Petri Nets. We can say that these delays are instantaneous, when we aim at timed guards} +However, the limitation of the GTS formalism resides in the lack of expressivity wrt the delays in failure propagation. +In timed Guarded Transition Systems -- an extension of GTSs -- a delay function is associated to each event, indicating the date when the event occurs. However, the propagation of messages, as failures, dealt by assertions, are not included in the (state) transitions that are delayed. + +in the case of flow variables, they are updated in AltaRica simultaneously, as they represent the instantaneous propagation of a message in a system. Here, adding delays in such transitions, cannot be directly done within the AltaRica models, so we had to hack it. +We introduced \say{delay buffers}, which, in the AltaRica modelling, have a flow variable as input, a delayed state transition, and an output, which value depends on the state variable, which has been updated only after a delay. See Fig.~\ref{fig:delay-buffer} + + + +The extension to temporal guards on the transitions expressed by the ETGTS falls out of the AltaRica expressiveness, so cannot be captured nor analysed by its associated tool, which can treat time as a set of delay assignment, i.e. with a fixed delay associated to each transition. +% Thus, the aforedefined Extended Temporal GTS is obtained from the AltaRica DataFlow model, by enriching it the syntax for temporal guarded transitions, i.e. by adding delays as defined in Def.~\ref{def:ETGTS} to the transitions in a new event law. +\end{comment} + +\subsection{Factored model of ETGTS} +Representing the whole state space can be costly. For this reason, instead of describing the ETGTS as a state space, it is preferable to define a factored version of +the ETGTS, and describing the associated semantics. + +AltaRica separates flow variables and state variables. +% State variables are modified by transitions, i.e. explicit changes of system configuration. +% +Delayed transitions affecting state variables are trivially extended to include a temporal interval in the guard matching the non-deterministic delay we plan to add. Flow variables are updated by assertions in AltaRica models, but this distinction between variables does not appear in the associated GTS; thus, in order to assign delays assertions, a auxiliary state variables and transitions are used to create a (delayed) state transition. + +Let be $V$ a finite set of variable, possible multi-valued, and let be $\sigma$ the function that associates to each variable its finite domain. +Thus, a variable assignment is here a function $f: V \to \sigma(v)$ for $v \in V$, associating to each $v \in V$ its value $f(v)$. +A state in $S$ is then a assignment of all variables $v \in V$. As syntactic sugar, we can express the evaluation of an expression $\epsilon$ over $V$ +in a state $s$ by considering $s(\epsilon)$. + +\begin{definition}[Factored ETGTS]\label{def:factored-ETGTS} + A GTS is a tuple $\langle V, O, I, \Delta\rangle $ where: + \begin{itemize} + \item $V$ is a set of variables, possibly multivalued, divided in two sets of variables: the set $St$ of \emph{state variables}, and $Fl$ of \emph{flow variables} s.t. $V = St \cup Fl.$ + \item $O$ is a finite set of operators, where each operator consists in + \begin{itemize} + \item a Boolean expressions $\Gamma$ built over $V$ called \emph{guard}; + \item a \emph{post-condition} instruction, a partial variable assignments $\P$. Post-conditions where the left members of the assignment are only state variables are referred as \emph{transitions}. Post-conditions where the left members of the assignment are only flow variables are referred as \emph{assertions}. + \end{itemize} + \item $I$ is the initial assignment of variables of $V$. + \item $\Delta$ is a delay function s.t. $\Delta: O \to \mathbb{R}^+ \times \mathbb{R}^+$, assigning an initial and a final firing time to the operators. We consider that, when not defined, the effects of the operators are instantaneous. + + \end{itemize} + \end{definition} + +We say that an operator $<\Gamma, P>$ is fireable in a state $s$ when the guard holds in $s$, i.e. +the variable assignment in $s$ is such that $s \models \Gamma$. +Assertions are concatenated to each transition, in order to update flow variables. +Thus, applying an operator in a state $s$ leads to a new state $s'$, obtained by applying first $P$ then the assertions to the variables in $s$ . % P(s) + +\subsubsection{Semantics of a ETGTS} + + +The semantics of a Temporal Extended GTS, associated to the above definition is a Kripke structure $\langle S, S_0, \to \rangle$ defining an oriented graph, where edges are labelled by the events, and their associated delays. + +\begin{definition}[Semantics of ETGTS]\label{def:ETGTS} + An Extended Timed Guarded Transition System is a tuple $\langle S, s_0, E, T, \tau \rangle $ where: + \begin{itemize} + \item $\mathcal{S} = S \cup \mathbb{R}_0^+$ is a set of states; + \item $\mathcal{S} _0 = s_0 \cup \{0\} \in S$ is the initial state; + \item $E$ is a set of event symbols; + \item $\tau$ is the delay relation, $\tau: E \to \mathbb{R}^+_0 \times \mathbb{R}^+_0$, assigning a minimal and a maximal delay to the transitions bound to event $e$. + \item $\mathcal{T}$ is a set of transitions s.t. $\mathcal{T} \subseteq \mathcal{S} \times E \times \mathcal{S}$. For sake of simplicity, we consider two different kinds of transitions that can be associated to an event $e$: + \begin{itemize} + \item transitions $s \xrightarrow{t} s'$, associating to a state $$ a new state $$, whith $t = (s, e, s')$ + \item timed transitions $s \xrightarrow{\theta} s'$, associating to a state $$ a new state $$, whith $\delta \in \tau(e)$ + \end{itemize} + \end{itemize} +% A transition $t \in T: (s, e, s')$ associates a state $s'$, to a state $s$ by executing the event $e$ in $s$, after a delay in the interval $[\delta_{min}, \delta_{max}]$ given by $\tau(e)$, +% such that $t = (s, e, s')$ and $$ + + A \emph{firing schedule} $\rho$ of a timed Transition System is a sequence of pairs event-time from the initial state $s_0$: + \begin{align*} + \rho &= \{ (e_1,\delta_1), \ldots, (e_n,\delta_n) \} \; + \text{s.t. } \forall i \;\delta_i \in \tau(e_i), \text{ and }\\ + &s_0 \xrightarrow{t_1} s_1 \xrightarrow{t_2}\cdots \xrightarrow{t_n} s_n, \text{ with } \forall i \;t_i = (s_{i-1}, e_i, s_i) \in T + \end{align*} +\end{definition} +\subsubsection{Translation} + +The states are of the form of $$, where $s \in S$ is a total assignment and $s_0$ is the initial assignment of variables in $V$; +$\theta$ is a real positive number. +Thus, transitions associate to pair $$ other pairs $$. % a transition $t in T$ + + +The translation from the ETGTS to an TPN is straightforward. + +A state in the ETGTS represents the marking of the TPN, so +we can associate to each variable assignment in a state of the ETGTS, tokens in a state of the TPN, +with the initial state $\mathcal{S} _0$ defining the initial markup $M_0$. +The set of events $\{e | e \in E\}$ are mapped in the set of transitions $\{t_e \in T| e \in E\}$ in the TPN, +with an arc $(s, e, s')$ corresponding to % $\{p' | v_p \in s \text{ and } F(p, t_e) \neq 0\}$, +the marking $M'$ resulting from the set of markings obtained by applying the transition $t_e$ to the set all the places with a not null token that activate the transition (i.e. $M$). +Wrt to the timed transitions +the firing interval $I'$ after a transition $t_e$ is obtained from the set of transitions in ETGTS that are fireable at $\theta'$ ( the timing obtained in the ETGTS after applying $e$ in $$) +such that $I' = \{\tau(t_e)\: | \: \theta' \in \tau(t_e) \}$. + +Such transitions affect state variables only, while flow variables are updated simultaneously only if are kept, possibly adding them a delay.\TODO{ (dessin de la fleur)} + +It is easy to see that the translated ETGTS is made of a single place and $n$ transitions, where $n$ corresponds to the number of state transitions in the initial model. We can ask ourselves if there is a more compact alternative to such a ``monolithic'' Petri Net. By enumerating the states in the model, we could create a ``stateful'' Petri net with a place for each reachable state, with the relative transitions. Another alternative for our translated model, would be to use a ``concurrent'' model, using different blocks for the different AltaRica nodes. + +In the worst case scenario, the number of transitions of the monolithic Petri net would be equal to the possible variable assignment; +when considering Boolean variables only, the possible truth values assignment to $k$ variables would be $2^k$. +On the other side, if we consider the stateful model, we would end up, in the worst case, with $2^k$ places and the same amount of transitions. +Using the concurrent Petri net, we could obtain $n2k$ places (with $n$ the number of AltaRica nodes) which, in the worst case, would end up with $n2^k$ transitions and states. This worst case analysis yields to the fact that the simple monolithic Petri net is the more compact way to represent the original AltaRica model. + + +%%%% Comment on how do we create a buffered block to transmit faults +\begin{comment} + +% It is easy to see from Def.~\ref{def:ETGTS} and Def.~\ref{def:PN} that any Petri Net can be modelled as a GTS~\cite{rau08}. % Any GTS in Petri Net? + + + +While transitions affecting the state variables updates support a direct expression of the delay in AltaRica (and hence in ETGTS as well), flow variables are updated by assertions, that natively do not support delays. To express a delayed failure affecting an input/output variable (a flow variable) auxiliary state variables and transitions have to be used to model the delay and the failure buffer. Thus, a delay element will depend on three parameters $(k, \delta_1, \delta_2)$, where $\delta_1$ and $\delta_2$ are indicate the minimal and the maximal delay (resp.), and $k$ indicates the maximal buffer for the element. + +\TODO{Following example is useless, as it has been explained clearly in the former sentence} +\subsubsection{Example} +Given a failure propagation represented by a flow variable $v$ as input $v_i$ of an element, the assertion $a$ updating these values would be such that $v_i = v$. To introduce a delay between $d_e$ and $d_e'$, we add to the AltaRica model two auxiliary state variables $w, w'$, and two new events $e$ and $e'$. +The event $e$ is instantaneous s.t. $\Delta(e_d) = (d_e, d_e')$, and the resulting transition assigns $w = v$. +The event $e_d$ is delayed s.t. $\Delta(e_d) = (d_e, d_e')$, and the resulting transition assigns $w' = w$. +The following assignments are added as assertions: $a': w' = w$, $a'': v_i = w'$. The result is delay of a value comprised in the interval $[d_e, d_e']$ between the assignment $w = v$, and the propagation to change the value of $v_i$. + +In OCAS, to produce such a model, N delay elements has to be created, with N the size of the buffer. This is automatised in our tool-chain, as the code corresponding to the delay element for $(k, \delta_1, \delta_2)$ is generated in Fiacre from the AltaRica code (where only the delay is indicated, while the buffer size $k$ is calculated from the elements uphill. +% NB: We can say that if the value v is new, THEN we update w. but can be more confusing. + +\subsection{From Timed GTS to Timed Petri Nets} +\TODO{1) Get definition of timed Petri Nets, 2) define the translation\\} +We build a state $s_0$, s.t. for each transition $t \in T$ in the TGTS, a transition $t \circ a$ from $s_0$ to $s_0$ is added in the TPN. Eventual delays are maintained. +It is easy to see that such transitions affect state variables only, while flow variables are updated simultaneously only if are kept, possibly adding them a delay. (dessin de la fleur) + + +For each delayed transition affecting a flow variable, e.g. a delay in the failure propagation in our example, we add a new element working as a buffer delaying the input messages. + + +Introducing the delay, synchronisation, and new states +1) first in OCAS; +2) AltaRica code generated with timed transitions; +3) Fiacre code, with temporal guards (from the timed transitions expressed before). + +Equivalence between the AltaRica models with no stochastic information, i.e. in Fiacre probabilities are abstracted away. Trivial to see that, when guards on transitions are conserved. Then, the time information is not part of the AltaRica models, and has there been artificially introduced for our purpose of taking trace of it during the translation. (taking trace of the transition names, for traceability purpose). + + +\end{comment} +%%% end comment + + +\section{Command line} + +Sources du projet disponibles sur (C++): + +\url{http://git-ingequip.pf.irt-aese.local/diffusion/TALTARICA/} + +Benchmarks (utilisés entre autre pour l'article IMBSA 2017): + +\url{http://git-ingequip.pf.irt-aese.local/diffusion/TALTARICA/browse/master/altarica\_epoch/benchmarks/models/} + + +In the IRT repository, we have: + +v.1.0-erts18 The version used for ERTS. + +v.1.1 Current version. Some bugs corrected + +Known bugs of v.1.0-erts18 + +Error in printing the guards of synchronized transitions: adds and 'and' at the end of the line when there are empty guards) +Duplicated syncronizations events + + +to compile : +/usr/bin/make KCFLAGS=-ggdb3 -Wdeprecated-declarations epochnogui + +to execute: + + ./src/console/epochnogui --ds 0 --ps 0 --file > + +%% LocalWords: TGTS Fiacre Dataflow OCAS ETGTS +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: diff --git a/doc/Rapport post-doc/dirtytalk.sty b/doc/Rapport post-doc/dirtytalk.sty new file mode 100644 index 0000000..228c5bd --- /dev/null +++ b/doc/Rapport post-doc/dirtytalk.sty @@ -0,0 +1,73 @@ +%% +%% This is file `dirtytalk.sty', +%% generated with the docstrip utility. +%% +%% The original source files were: +%% +%% dirtytalk.dtx (with options: `package') +%% +%% M. Klammler, 2010 +%% +%% I, the copyright holder of this work, release the source code of the dirtytalk +%% package as well as the accompaining documentation into the public domain. This +%% applies worldwide. +%% +%% In some countries this may not be legally possible; if so: I grant anyone the +%% right to use this work for any purpose, without any conditions, unless such +%% conditions are required by law. +%% + +\NeedsTeXFormat{LaTeX2e} +\ProvidesPackage{dirtytalk}[2010/11/21 A package making "quoting" easier] +\RequirePackage{kvoptions} +\newcommand{\dirtytalk@lqq}{``} +\newcommand{\dirtytalk@rqq}{''} +\newcommand{\dirtytalk@lq}{`} +\newcommand{\dirtytalk@rq}{'} +\DeclareStringOption{left} +\DeclareStringOption{right} +\DeclareStringOption{leftsub} +\DeclareStringOption{rightsub} +\ProcessKeyvalOptions* +\RequirePackage{ifthen} +\ifthenelse% + {\equal{\dirtytalk@left}{}}% + {}% + {\renewcommand{\dirtytalk@lqq}{\dirtytalk@left}} +\ifthenelse% + {\equal{\dirtytalk@right}{}}% + {}% + {\renewcommand{\dirtytalk@rqq}{\dirtytalk@right}} +\ifthenelse% + {\equal{\dirtytalk@leftsub}{}}% + {}% + {\renewcommand{\dirtytalk@lq}{\dirtytalk@leftsub}} +\ifthenelse% + {\equal{\dirtytalk@rightsub}{}}% + {}% + {\renewcommand{\dirtytalk@rq}{\dirtytalk@rightsub}} +\newcounter{dirtytalk@qdepth} +\newcommand% + {\dirtytalk@lsymb}% + {\ifthenelse% + {\value{dirtytalk@qdepth}>1}% + {\dirtytalk@lq}% + {\dirtytalk@lqq}% + }% +\newcommand{\dirtytalk@rsymb}% + {\ifthenelse% + {\value{dirtytalk@qdepth}>1}% + {\dirtytalk@rq}% + {\dirtytalk@rqq}% + } +\providecommand{\say}[1]% + {% + \addtocounter{dirtytalk@qdepth}{1}% + \dirtytalk@lsymb% + #1% + \dirtytalk@rsymb% + \addtocounter{dirtytalk@qdepth}{-1}% + } +\endinput +%% +%% End of file `dirtytalk.sty'. diff --git a/doc/Rapport post-doc/etgts.tex b/doc/Rapport post-doc/etgts.tex new file mode 100644 index 0000000..8d1a6b6 --- /dev/null +++ b/doc/Rapport post-doc/etgts.tex @@ -0,0 +1,130 @@ +\section{Method and translation}\label{sec:sect3} + +\subsection{Temporal Petri Nets} + + +\subsection{From AltaRica to Tina} +The underlying mathematical model of the AltaRica language is a Guarded Transition System (GTS), an automaton that generalises Reliability Block Diagrams, Markov chains and Stochastic Petri nets~\cite{rau08}. In GTS, states are represented by value assignment to variables, while the states transitions are triggered by events, that change the variables value. Synchronisation between events (habitually asynchronous) is produced by introducing a new event. + +Given that it is always possible to obtain a flattened model from a +composition of interconnected AltaRica nodes, it is then possible to +interpret a (general) AltaRica model by using the GTS model encoding. +Our translation approach relies on Extended Timed Guarded Transition system, an extension of the GTS of AltaRica opportunely enriched to include timed guards. + + +\begin{definition}[ETGTS]\label{def:ETGTS} + An Extended Timed Guarded Transition System is a tuple $\langle S, s_0, E, T, \tau \rangle $ where: + \begin{itemize} + \item $S$ is a set of states; + \item $s_0 \in S$ is the initial state; + \item $E$ is a set of event symbols; + \item $T$ is a set of transitions s.t. $T \subseteq S \times E \times S$. + \item $\tau$ is the delay relation, $\tau: E \to \mathbb{R}^+ \times \mathbb{R}^+$, assigning a minimal and a maximal delay to the transitions bound to event $e$. + \end{itemize} + A transition $t \in T: (s, e, s')$ associates a state $s'$, to a state $s$ by executing the event $e$ in $s$, after a delay in the interval $[\delta_{min}, \delta_{max}]$ given by $\tau(e)$. + An ETGTS defines an oriented graph, where delays can be seen as labels attached to the edges. + + A \emph{run} $\rho$ of a timed Transition System is a sequence of pairs event-time from the initial state $s_0$: + \begin{align*} + \rho &= \{ (e_1,\delta_1), \ldots, (e_n,\delta_n) \} \; + \text{s.t. } \forall i \;\delta_i \in \tau(e_i), \text{ and }\\ + &s_0 \xrightarrow{t_1} s_1 \xrightarrow{t_2}\cdots \xrightarrow{t_n} s_n, \text{ with } \forall i \;t_i = (s_{i-1}, e_i, s_i) \in T + \end{align*} + \end{definition} + + +\begin{comment} + %%%%start comment +\TODO{TGTS for us, as delta can be used, but not necessary} + +\begin{definition}[GTS]\label{def:GTS} + A GTS is a tuple $\langle V,E,T, A, \nu \rangle $ where: + \begin{itemize} + \item $V$ is a set of variables, divided in two sets of variables: the set $S$ of \emph{state variables}, and $F$ of \emph{flow variables} s.t. $V = S \cup F.$ + \item $E$ is a set of event symbols + \item $T$ is a set of transitions, s.t. $t \equiv (\gamma, e, \varphi) \in T$ with $e \in E$, $\gamma$ and $\varphi$ are Boolean expressions built over $V$ called \emph{guard} and \emph{post-condition} resp. A transition $t$ applies in a state $s \in 2^{|V|}$ s.t. $s \models \gamma$, resulting in a state $s' \models \varphi$. + \item $A$ is the set of \emph{assertions}, i.e. Boolean expressions built over $V$. Assertions are concatenated to each transition, in order to update flow variables, \TODO{modelling the failure propagation. } + \item $\nu$ is the initial assignment of variables of $V$. + \end{itemize} + \end{definition} + +\TODO{1) define the semantics of a transition, i.e. how to pass from a state $\sigma$ to a state $\rho$. 2) define a trace in the timed graph, with events labelled by the firing time, i.e. a plan for Tina} + +A GTS is a (possibly infinite) graph $\Gamma = (\Sigma, \Theta)$, where $\Sigma$ is a set of nodes given by all the possible variable assignments in $V$, and $\Theta$ is a set of guarded transitions $(\sigma, e, \rho)$, where $\sigma, \rho \in \Sigma$ and $e \in E$. + +blocks and processes, from the GTS to the Petri Net (states, places, tokens). + +\begin{definition}[Temporal GTS]\label{TTGTS} +\TODO{Timed GTS already exist, we can use another name to avoid confusion} +A Temporal Guarded Transition System is a tuple $\langle V,E,T, A,\nu, \Delta \rangle$ where + \begin{itemize} + \item $\langle V,E,T, A, \nu \rangle $ is a GTS defined as in Def.~\ref{def:GTS} + \item $\Delta$ is a delay function s.t. $\Delta: E \to \mathbb{R}^+ \times \mathbb{R}^+$, assigning an initial and a final firing time to the transitions bound to event $e$. + \end{itemize} +\end{definition} + + +\TODO{Next paragraph is possibly untrue, as TGTS can be modified such to include delay \emph{functions} as we did with Fiacre and Petri Nets. We can say that these delays are instantaneous, when we aim at timed guards} +However, the limitation of the GTS formalism resides in the lack of expressivity wrt the delays in failure propagation. +In timed Guarded Transition Systems -- an extension of GTSs -- a delay function is associated to each event, indicating the date when the event occurs. However, the propagation of messages, as failures, dealt by assertions, are not included in the (state) transitions that are delayed. + +in the case of flow variables, they are updated in AltaRica simultaneously, as they represent the instantaneous propagation of a message in a system. Here, adding delays in such transitions, cannot be directly done within the AltaRica models, so we had to hack it. +We introduced \say{delay buffers}, which, in the AltaRica modelling, have a flow variable as input, a delayed state transition, and an output, which value depends on the state variable, which has been updated only after a delay. See Fig.~\ref{fig:delay-buffer} + + +\end{comment} +%%%%%% end comment} +Thus, a Temporal Extended GTS models a graph with transitions labelled by events and by time. + + + +It is easy to see from Def.~\ref{def:ETGTS} and Def.~\ref{def:PN} that any Petri Net can be modelled as a GTS~\cite{rau08}. % Any GTS in Petri Net? + +The extension to temporal guards on the transitions expressed by the ETGTS falls out of the AltaRica expressiveness, so cannot be captured nor analysed by its associated tool, which can treat time as a set of delay assignment, i.e. with a fixed delay associated to each transition. +Thus, the aforedefined Extended Temporal GTS is obtained from the AltaRica DataFlow model, by enriching it the syntax for temporal guarded transitions, i.e. by adding delays as defined in Def.~\ref{def:ETGTS} to the transitions in a new event law. + +AltaRica separates flow variables and state variables. +% State variables are modified by transitions, i.e. explicit changes of system configuration. +% +Delayed transitions affecting state variables are trivially extended to include a temporal interval in the guard matching the non-deterministic delay we plan to add. Flow variables are updated by assertions in AltaRica models, but this distinction between variables does not appear in the associated GTS; thus, in order to assign delays assertions, a auxiliary state variables and transitions are used to create a (delayed) state transition. + + +%%%% Comment on how do we create a buffered block to transmit faults +\begin{comment} +While transitions affecting the state variables updates support a direct expression of the delay in AltaRica (and hence in ETGTS as well), flow variables are updated by assertions, that natively do not support delays. To express a delayed failure affecting an input/output variable (a flow variable) auxiliary state variables and transitions have to be used to model the delay and the failure buffer. Thus, a delay element will depend on three parameters $(k, \delta_1, \delta_2)$, where $\delta_1$ and $\delta_2$ are indicate the minimal and the maximal delay (resp.), and $k$ indicates the maximal buffer for the element. + +\TODO{Following example is useless, as it has been explained clearly in the former sentence} +\subsubsection{Example} +Given a failure propagation represented by a flow variable $v$ as input $v_i$ of an element, the assertion $a$ updating these values would be such that $v_i = v$. To introduce a delay between $d_e$ and $d_e'$, we add to the AltaRica model two auxiliary state variables $w, w'$, and two new events $e$ and $e'$. +The event $e$ is instantaneous s.t. $\Delta(e_d) = (d_e, d_e')$, and the resulting transition assigns $w = v$. +The event $e_d$ is delayed s.t. $\Delta(e_d) = (d_e, d_e')$, and the resulting transition assigns $w' = w$. +The following assignments are added as assertions: $a': w' = w$, $a'': v_i = w'$. The result is delay of a value comprised in the interval $[d_e, d_e']$ between the assignment $w = v$, and the propagation to change the value of $v_i$. + +In OCAS, to produce such a model, N delay elements has to be created, with N the size of the buffer. This is automatised in our tool-chain, as the code corresponding to the delay element for $(k, \delta_1, \delta_2)$ is generated in Fiacre from the AltaRica code (where only the delay is indicated, while the buffer size $k$ is calculated from the elements uphill. +% NB: We can say that if the value v is new, THEN we update w. but can be more confusing. +\end{comment} +%%% end comment + + + +\subsection{From Timed GTS to Timed Petri Nets} +\TODO{1) Get definition of timed Petri Nets, 2) define the translation\\} +We build a state $s_0$, s.t. for each transition $t \in T$ in the TGTS, a transition $t \circ a$ from $s_0$ to $s_0$ is added in the TPN. Eventual delays are maintained. +It is easy to see that such transitions affect state variables only, while flow variables are updated simultaneously only if are kept, possibly adding them a delay. (dessin de la fleur) + + +For each delayed transition affecting a flow variable, e.g. a delay in the failure propagation in our example, we add a new element working as a buffer delaying the input messages. + + +Introducing the delay, synchronisation, and new states +1) first in OCAS; +2) AltaRica code generated with timed transitions; +3) Fiacre code, with temporal guards (from the timed transitions expressed before). + +Equivalence between the AltaRica models with no stochastic information, i.e. in Fiacre probabilities are abstracted away. Trivial to see that, when guards on transitions are conserved. Then, the time information is not part of the AltaRica models, and has there been artificially introduced for our purpose of taking trace of it during the translation. (taking trace of the transition names, for traceability purpose). + + + + + +%% LocalWords: TGTS Fiacre DataFlow OCAS ETGTS diff --git a/doc/Rapport post-doc/figures/0- AOCS mode Abstract.png b/doc/Rapport post-doc/figures/0- AOCS mode Abstract.png new file mode 100644 index 0000000..8e4716d Binary files /dev/null and b/doc/Rapport post-doc/figures/0- AOCS mode Abstract.png differ diff --git a/doc/Rapport post-doc/figures/2-2 - AOCS mode automaton.png b/doc/Rapport post-doc/figures/2-2 - AOCS mode automaton.png new file mode 100644 index 0000000..564e4e8 Binary files /dev/null and b/doc/Rapport post-doc/figures/2-2 - AOCS mode automaton.png differ diff --git a/doc/Rapport post-doc/figures/2-3 - ASH mode.png b/doc/Rapport post-doc/figures/2-3 - ASH mode.png new file mode 100644 index 0000000..cf9b35d Binary files /dev/null and b/doc/Rapport post-doc/figures/2-3 - ASH mode.png differ diff --git a/doc/Rapport post-doc/figures/2-4 set ON the equipment for ASM mode.png b/doc/Rapport post-doc/figures/2-4 set ON the equipment for ASM mode.png new file mode 100644 index 0000000..ddc5200 Binary files /dev/null and b/doc/Rapport post-doc/figures/2-4 set ON the equipment for ASM mode.png differ diff --git a/doc/Rapport post-doc/figures/2-5 ACM automaton.png b/doc/Rapport post-doc/figures/2-5 ACM automaton.png new file mode 100644 index 0000000..fd62c3b Binary files /dev/null and b/doc/Rapport post-doc/figures/2-5 ACM automaton.png differ diff --git a/doc/Rapport post-doc/figures/2-6 set ON the equipment for ACM mode.png b/doc/Rapport post-doc/figures/2-6 set ON the equipment for ACM mode.png new file mode 100644 index 0000000..106b2e6 Binary files /dev/null and b/doc/Rapport post-doc/figures/2-6 set ON the equipment for ACM mode.png differ diff --git a/doc/Rapport post-doc/figures/2-7 Collision Avoidance Mode.png b/doc/Rapport post-doc/figures/2-7 Collision Avoidance Mode.png new file mode 100644 index 0000000..2b6e06d Binary files /dev/null and b/doc/Rapport post-doc/figures/2-7 Collision Avoidance Mode.png differ diff --git a/doc/Rapport post-doc/figures/2-8 OCM automaton.png b/doc/Rapport post-doc/figures/2-8 OCM automaton.png new file mode 100644 index 0000000..d240c1b Binary files /dev/null and b/doc/Rapport post-doc/figures/2-8 OCM automaton.png differ diff --git a/doc/Rapport post-doc/figures/2-9 Formation Control Mode.png b/doc/Rapport post-doc/figures/2-9 Formation Control Mode.png new file mode 100644 index 0000000..d3eb445 Binary files /dev/null and b/doc/Rapport post-doc/figures/2-9 Formation Control Mode.png differ diff --git a/doc/Rapport post-doc/figures/AOCS mode.png b/doc/Rapport post-doc/figures/AOCS mode.png new file mode 100644 index 0000000..a5cf782 Binary files /dev/null and b/doc/Rapport post-doc/figures/AOCS mode.png differ diff --git a/doc/Rapport post-doc/figures/AOCSmode_schema.png b/doc/Rapport post-doc/figures/AOCSmode_schema.png new file mode 100644 index 0000000..9a5276b Binary files /dev/null and b/doc/Rapport post-doc/figures/AOCSmode_schema.png differ diff --git a/doc/Rapport post-doc/figures/AirSpeed_Computation.jpg b/doc/Rapport post-doc/figures/AirSpeed_Computation.jpg new file mode 100644 index 0000000..5756bbc Binary files /dev/null and b/doc/Rapport post-doc/figures/AirSpeed_Computation.jpg differ diff --git a/doc/Rapport post-doc/figures/ERTS - AOCS mode.png b/doc/Rapport post-doc/figures/ERTS - AOCS mode.png new file mode 100644 index 0000000..a5cf782 Binary files /dev/null and b/doc/Rapport post-doc/figures/ERTS - AOCS mode.png differ diff --git a/doc/Rapport post-doc/figures/EUTELSAT-172B-SATELLITE.jpg b/doc/Rapport post-doc/figures/EUTELSAT-172B-SATELLITE.jpg new file mode 100644 index 0000000..e364300 Binary files /dev/null and b/doc/Rapport post-doc/figures/EUTELSAT-172B-SATELLITE.jpg differ diff --git a/doc/Rapport post-doc/figures/Equipment Mode.png b/doc/Rapport post-doc/figures/Equipment Mode.png new file mode 100644 index 0000000..99f4c8f Binary files /dev/null and b/doc/Rapport post-doc/figures/Equipment Mode.png differ diff --git a/doc/Rapport post-doc/figures/Function2_1.pdf b/doc/Rapport post-doc/figures/Function2_1.pdf new file mode 100644 index 0000000..12d13bf Binary files /dev/null and b/doc/Rapport post-doc/figures/Function2_1.pdf differ diff --git a/doc/Rapport post-doc/figures/Function2_1.png b/doc/Rapport post-doc/figures/Function2_1.png new file mode 100644 index 0000000..bc9e975 Binary files /dev/null and b/doc/Rapport post-doc/figures/Function2_1.png differ diff --git a/doc/Rapport post-doc/figures/Function2_1.svg b/doc/Rapport post-doc/figures/Function2_1.svg new file mode 100644 index 0000000..d11ed01 --- /dev/null +++ b/doc/Rapport post-doc/figures/Function2_1.svg @@ -0,0 +1,271 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + I1 + I2 + O + + + diff --git a/doc/Rapport post-doc/figures/Function2_1.tex b/doc/Rapport post-doc/figures/Function2_1.tex new file mode 100644 index 0000000..f61c39a --- /dev/null +++ b/doc/Rapport post-doc/figures/Function2_1.tex @@ -0,0 +1,306 @@ +%LaTeX with PSTricks extensions +%%Creator: inkscape 0.91 +%%Please note this file requires PSTricks extensions +\psset{xunit=.5pt,yunit=.5pt,runit=.5pt} +\begin{pspicture}(277.28570352,147.28573176) +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=2.24441051,linecolor=curcolor] +{ +\newpath +\moveto(78.66506154,118.62066234) +\lineto(204.33494527,118.62066234) +\lineto(204.33494527,29.37935985) +\lineto(78.66506154,29.37935985) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0.627451 0.16862746} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(155.05655629,73.51595653) +\curveto(155.05655629,66.61239716)(149.46011566,61.01595653)(142.55655629,61.01595653) +\curveto(135.65299692,61.01595653)(130.05655629,66.61239716)(130.05655629,73.51595653) +\curveto(130.05655629,80.4195159)(135.65299692,86.01595653)(142.55655629,86.01595653) +\curveto(149.46011566,86.01595653)(155.05655629,80.4195159)(155.05655629,73.51595653) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=1.29999995,linecolor=curcolor] +{ +\newpath +\moveto(16.64285,99.07143176) +\lineto(64.93478,99.07143176) +\lineto(75.92857,99.07143176) +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(62.03098996,104.83967288) +\lineto(77.65499392,99.09433072) +\lineto(62.0309891,93.34898981) +\curveto(64.52705172,96.74103678)(64.51266935,101.38194574)(62.03098996,104.83967288) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=0.89374997,linecolor=curcolor] +{ +\newpath +\moveto(62.03098996,104.83967288) +\lineto(77.65499392,99.09433072) +\lineto(62.0309891,93.34898981) +\curveto(64.52705172,96.74103678)(64.51266935,101.38194574)(62.03098996,104.83967288) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=3,linecolor=curcolor] +{ +\newpath +\moveto(13.8023,99.20921176) +\lineto(73.8023,99.20921176) +\lineto(73.8023,99.20921176) +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=1.29999995,linecolor=curcolor] +{ +\newpath +\moveto(16.64285,49.07142876) +\lineto(64.93478,49.07142876) +\lineto(75.92857,49.07142876) +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(62.03098996,54.83966988) +\lineto(77.65499392,49.09432772) +\lineto(62.0309891,43.34898681) +\curveto(64.52705172,46.74103378)(64.51266935,51.38194274)(62.03098996,54.83966988) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=0.89374997,linecolor=curcolor] +{ +\newpath +\moveto(62.03098996,54.83966988) +\lineto(77.65499392,49.09432772) +\lineto(62.0309891,43.34898681) +\curveto(64.52705172,46.74103378)(64.51266935,51.38194274)(62.03098996,54.83966988) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=3,linecolor=curcolor] +{ +\newpath +\moveto(13.8023,49.20920876) +\lineto(73.8023,49.20920876) +\lineto(73.8023,49.20920876) +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=1.29999995,linecolor=curcolor] +{ +\newpath +\moveto(207.35714,74.07142876) +\lineto(255.64907,74.07142876) +\lineto(266.64286,74.07142876) +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(252.74527996,79.83966988) +\lineto(268.36928392,74.09432772) +\lineto(252.7452791,68.34898681) +\curveto(255.24134172,71.74103378)(255.22695935,76.38194274)(252.74527996,79.83966988) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=0.89374997,linecolor=curcolor] +{ +\newpath +\moveto(252.74527996,79.83966988) +\lineto(268.36928392,74.09432772) +\lineto(252.7452791,68.34898681) +\curveto(255.24134172,71.74103378)(255.22695935,76.38194274)(252.74527996,79.83966988) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linewidth=3,linecolor=curcolor] +{ +\newpath +\moveto(204.51659,74.20920876) +\lineto(264.51659,74.20920876) +\lineto(264.51659,74.20920876) +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(20.05469472,109.49108471) +\lineto(23.41406972,108.96374096) +\lineto(23.41406972,107.92858471) +\lineto(12.94531972,107.92858471) +\lineto(12.94531972,108.96374096) +\lineto(16.30469472,109.49108471) +\lineto(16.30469472,132.57702221) +\lineto(12.94531972,133.08483471) +\lineto(12.94531972,134.11999096) +\lineto(23.41406972,134.11999096) +\lineto(23.41406972,133.08483471) +\lineto(20.05469472,132.57702221) +\lineto(20.05469472,109.49108471) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(37.10547597,109.49108471) +\lineto(42.45703847,108.96374096) +\lineto(42.45703847,107.92858471) +\lineto(28.37500722,107.92858471) +\lineto(28.37500722,108.96374096) +\lineto(33.74610097,109.49108471) +\lineto(33.74610097,130.85827221) +\lineto(28.45313222,128.96374096) +\lineto(28.45313222,129.99889721) +\lineto(36.08985097,134.33483471) +\lineto(37.10547597,134.33483471) +\lineto(37.10547597,109.49108471) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(19.95703847,10.20537914) +\lineto(23.31641347,9.67803539) +\lineto(23.31641347,8.64287914) +\lineto(12.84766347,8.64287914) +\lineto(12.84766347,9.67803539) +\lineto(16.20703847,10.20537914) +\lineto(16.20703847,33.29131664) +\lineto(12.84766347,33.79912914) +\lineto(12.84766347,34.83428539) +\lineto(23.31641347,34.83428539) +\lineto(23.31641347,33.79912914) +\lineto(19.95703847,33.29131664) +\lineto(19.95703847,10.20537914) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(42.55469472,8.64287914) +\lineto(26.51953847,8.64287914) +\lineto(26.51953847,11.51397289) +\curveto(27.83464263,12.73793122)(29.03906972,13.83168122)(30.13281972,14.79522289) +\curveto(31.23959055,15.77178539)(32.22917388,16.67673331)(33.10156972,17.51006664) +\curveto(33.98698638,18.35642081)(34.75521555,19.16371247)(35.40625722,19.93194164) +\curveto(36.07031972,20.70017081)(36.61719472,21.50095206)(37.04688222,22.33428539) +\curveto(37.48959055,23.16761872)(37.81511138,24.06605622)(38.02344472,25.02959789) +\curveto(38.24479888,25.99313956)(38.35547597,27.08037914)(38.35547597,28.29131664) +\curveto(38.35547597,29.98402497)(37.97136138,31.27308747)(37.20313222,32.15850414) +\curveto(36.43490305,33.04392081)(35.17839263,33.48662914)(33.43360097,33.48662914) +\curveto(33.04297597,33.48662914)(32.65235097,33.45407706)(32.26172597,33.38897289) +\curveto(31.8841218,33.33688956)(31.51953847,33.25876456)(31.16797597,33.15459789) +\curveto(30.81641347,33.06345206)(30.48438222,32.95277497)(30.17188222,32.82256664) +\curveto(29.87240305,32.70537914)(29.60547597,32.58168122)(29.37110097,32.45147289) +\lineto(28.68750722,29.24834789) +\lineto(27.39844472,29.24834789) +\lineto(27.39844472,34.28741039) +\curveto(28.38802805,34.52178539)(29.35808013,34.71709789)(30.30860097,34.87334789) +\curveto(31.27214263,35.04261872)(32.3138093,35.12725414)(33.43360097,35.12725414) +\curveto(36.2981843,35.12725414)(38.4466218,34.52829581)(39.87891347,33.33037914) +\curveto(41.32422597,32.14548331)(42.04688222,30.46579581)(42.04688222,28.29131664) +\curveto(42.04688222,27.22360831)(41.90365305,26.23402497)(41.61719472,25.32256664) +\curveto(41.34375722,24.41110831)(40.9466218,23.53220206)(40.42578847,22.68584789) +\curveto(39.90495513,21.85251456)(39.2669343,21.02569164)(38.51172597,20.20537914) +\curveto(37.75651763,19.39808747)(36.89714263,18.55824372)(35.93360097,17.68584789) +\curveto(34.9700593,16.81345206)(33.90886138,15.88246247)(32.75000722,14.89287914) +\curveto(31.60417388,13.91631664)(30.38021555,12.83558747)(29.07813222,11.65069164) +\lineto(42.55469472,11.65069164) +\lineto(42.55469472,8.64287914) +\closepath +} +} +{ +\newrgbcolor{curcolor}{0 0 0} +\pscustom[linestyle=none,fillstyle=solid,fillcolor=curcolor] +{ +\newpath +\moveto(232.22266347,96.76787914) +\curveto(232.22266347,94.94496247)(232.35938222,93.29782706)(232.63281972,91.82647289) +\curveto(232.90625722,90.35511872)(233.37500722,89.09860831)(234.03906972,88.05694164) +\curveto(234.70313222,87.01527497)(235.5950593,86.20798331)(236.71485097,85.63506664) +\curveto(237.83464263,85.07517081)(239.24089263,84.79522289)(240.93360097,84.79522289) +\curveto(242.6263093,84.79522289)(244.0325593,85.07517081)(245.15235097,85.63506664) +\curveto(246.27214263,86.20798331)(247.16406972,87.01527497)(247.82813222,88.05694164) +\curveto(248.50521555,89.09860831)(248.98047597,90.35511872)(249.25391347,91.82647289) +\curveto(249.52735097,93.29782706)(249.66406972,94.94496247)(249.66406972,96.76787914) +\curveto(249.66406972,98.57777497)(249.52735097,100.21188956)(249.25391347,101.67022289) +\curveto(248.98047597,103.12855622)(248.50521555,104.36553539)(247.82813222,105.38116039) +\curveto(247.16406972,106.40980622)(246.27214263,107.19756664)(245.15235097,107.74444164) +\curveto(244.0325593,108.29131664)(242.6263093,108.56475414)(240.93360097,108.56475414) +\curveto(239.24089263,108.56475414)(237.83464263,108.29131664)(236.71485097,107.74444164) +\curveto(235.5950593,107.19756664)(234.70313222,106.40980622)(234.03906972,105.38116039) +\curveto(233.37500722,104.36553539)(232.90625722,103.12855622)(232.63281972,101.67022289) +\curveto(232.35938222,100.21188956)(232.22266347,98.57777497)(232.22266347,96.76787914) +\closepath +\moveto(228.14063222,96.76787914) +\curveto(228.14063222,99.08558747)(228.42058013,101.08428539)(228.98047597,102.76397289) +\curveto(229.55339263,104.44366039)(230.38021555,105.83037914)(231.46094472,106.92412914) +\curveto(232.54167388,108.01787914)(233.8763093,108.82517081)(235.46485097,109.34600414) +\curveto(237.05339263,109.86683747)(238.8763093,110.12725414)(240.93360097,110.12725414) +\curveto(242.92578847,110.12725414)(244.70964263,109.86683747)(246.28516347,109.34600414) +\curveto(247.87370513,108.82517081)(249.22136138,108.01787914)(250.32813222,106.92412914) +\curveto(251.43490305,105.83037914)(252.28125722,104.44366039)(252.86719472,102.76397289) +\curveto(253.45313222,101.08428539)(253.74610097,99.08558747)(253.74610097,96.76787914) +\curveto(253.74610097,94.45017081)(253.45313222,92.43845206)(252.86719472,90.73272289) +\curveto(252.28125722,89.04001456)(251.43490305,87.64027497)(250.32813222,86.53350414) +\curveto(249.22136138,85.42673331)(247.87370513,84.59991039)(246.28516347,84.05303539) +\curveto(244.70964263,83.51918122)(242.92578847,83.25225414)(240.93360097,83.25225414) +\curveto(238.94141347,83.25225414)(237.1575593,83.51918122)(235.58203847,84.05303539) +\curveto(234.00651763,84.59991039)(232.6653718,85.42673331)(231.55860097,86.53350414) +\curveto(230.45183013,87.64027497)(229.60547597,89.04001456)(229.01953847,90.73272289) +\curveto(228.43360097,92.43845206)(228.14063222,94.45017081)(228.14063222,96.76787914) +\closepath +} +} +\end{pspicture} diff --git a/doc/Rapport post-doc/figures/Function2_2.pdf b/doc/Rapport post-doc/figures/Function2_2.pdf new file mode 100644 index 0000000..38888d3 Binary files /dev/null and b/doc/Rapport post-doc/figures/Function2_2.pdf differ diff --git a/doc/Rapport post-doc/figures/Function2_2.png b/doc/Rapport post-doc/figures/Function2_2.png new file mode 100644 index 0000000..3513174 Binary files /dev/null and b/doc/Rapport post-doc/figures/Function2_2.png differ diff --git a/doc/Rapport post-doc/figures/Function2_2.svg b/doc/Rapport post-doc/figures/Function2_2.svg new file mode 100644 index 0000000..9241d32 --- /dev/null +++ b/doc/Rapport post-doc/figures/Function2_2.svg @@ -0,0 +1,276 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + nominal + lost + erroneous + + + diff --git a/doc/Rapport post-doc/figures/Gnc mode simplifie.png b/doc/Rapport post-doc/figures/Gnc mode simplifie.png new file mode 100644 index 0000000..e936bfd Binary files /dev/null and b/doc/Rapport post-doc/figures/Gnc mode simplifie.png differ diff --git a/doc/Rapport post-doc/figures/Modele0.png b/doc/Rapport post-doc/figures/Modele0.png new file mode 100644 index 0000000..a6f09f5 Binary files /dev/null and b/doc/Rapport post-doc/figures/Modele0.png differ diff --git a/doc/Rapport post-doc/figures/Modele0F4.png b/doc/Rapport post-doc/figures/Modele0F4.png new file mode 100644 index 0000000..3940f2a Binary files /dev/null and b/doc/Rapport post-doc/figures/Modele0F4.png differ diff --git a/doc/Rapport post-doc/figures/Modele1.png b/doc/Rapport post-doc/figures/Modele1.png new file mode 100644 index 0000000..aedcab4 Binary files /dev/null and b/doc/Rapport post-doc/figures/Modele1.png differ diff --git a/doc/Rapport post-doc/figures/Modele2.png b/doc/Rapport post-doc/figures/Modele2.png new file mode 100644 index 0000000..480e219 Binary files /dev/null and b/doc/Rapport post-doc/figures/Modele2.png differ diff --git a/doc/Rapport post-doc/figures/passerelle.png b/doc/Rapport post-doc/figures/passerelle.png new file mode 100644 index 0000000..36088d9 Binary files /dev/null and b/doc/Rapport post-doc/figures/passerelle.png differ diff --git a/doc/Rapport post-doc/figures/satellite_telecom.png b/doc/Rapport post-doc/figures/satellite_telecom.png new file mode 100644 index 0000000..87cc13d Binary files /dev/null and b/doc/Rapport post-doc/figures/satellite_telecom.png differ diff --git a/doc/Rapport post-doc/figures/space_systems_2.jpg b/doc/Rapport post-doc/figures/space_systems_2.jpg new file mode 100644 index 0000000..9d449dc Binary files /dev/null and b/doc/Rapport post-doc/figures/space_systems_2.jpg differ diff --git a/doc/Rapport post-doc/figures/table1.png b/doc/Rapport post-doc/figures/table1.png new file mode 100644 index 0000000..464a901 Binary files /dev/null and b/doc/Rapport post-doc/figures/table1.png differ diff --git a/doc/Rapport post-doc/figures/texput.log b/doc/Rapport post-doc/figures/texput.log new file mode 100644 index 0000000..a6f2950 --- /dev/null +++ b/doc/Rapport post-doc/figures/texput.log @@ -0,0 +1,21 @@ +This is pdfTeX, Version 3.14159265-2.6-1.40.16 (TeX Live 2015/Debian) (preloaded format=pdflatex 2016.4.22) 7 FEB 2017 14:20 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +**main.tex + +! Emergency stop. +<*> main.tex + +End of file on the terminal! + + +Here is how much of TeX's memory you used: + 3 strings out of 494924 + 106 string characters out of 6179708 + 45773 words of memory out of 5000000 + 3399 multiletter control sequences out of 15000+600000 + 3640 words of font info for 14 fonts, out of 8000000 for 9000 + 14 hyphenation exceptions out of 8191 + 0i,0n,0p,1b,6s stack positions out of 5000i,500n,10000p,200000b,80000s +! ==> Fatal error occurred, no output PDF file produced! diff --git a/doc/Rapport post-doc/llncsdoc.sty b/doc/Rapport post-doc/llncsdoc.sty new file mode 100644 index 0000000..5843cba --- /dev/null +++ b/doc/Rapport post-doc/llncsdoc.sty @@ -0,0 +1,42 @@ +% This is LLNCSDOC.STY the modification of the +% LLNCS class file for the documentation of +% the class itself. +% +\def\AmS{{\protect\usefont{OMS}{cmsy}{m}{n}% + A\kern-.1667em\lower.5ex\hbox{M}\kern-.125emS}} +\def\AmSTeX{{\protect\AmS-\protect\TeX}} +% +\def\ps@myheadings{\let\@mkboth\@gobbletwo +\def\@oddhead{\hbox{}\hfil\small\rm\rightmark +\qquad\thepage}% +\def\@oddfoot{}\def\@evenhead{\small\rm\thepage\qquad +\leftmark\hfil}% +\def\@evenfoot{}\def\sectionmark##1{}\def\subsectionmark##1{}} +\ps@myheadings +% +\setcounter{tocdepth}{2} +% +\renewcommand{\labelitemi}{--} +\newenvironment{alpherate}% +{\renewcommand{\labelenumi}{\alph{enumi})}\begin{enumerate}}% +{\end{enumerate}\renewcommand{\labelenumi}{enumi}} +% +\def\bibauthoryear{\begingroup +\def\thebibliography##1{\section*{References}% + \small\list{}{\settowidth\labelwidth{}\leftmargin\parindent + \itemindent=-\parindent + \labelsep=\z@ + \usecounter{enumi}}% + \def\newblock{\hskip .11em plus .33em minus -.07em}% + \sloppy + \sfcode`\.=1000\relax}% + \def\@cite##1{##1}% + \def\@lbibitem[##1]##2{\item[]\if@filesw + {\def\protect####1{\string ####1\space}\immediate + \write\@auxout{\string\bibcite{##2}{##1}}}\fi\ignorespaces}% +\begin{thebibliography}{} +\bibitem[1982]{clar:eke3} Clarke, F., Ekeland, I.: Nonlinear +oscillations and boundary-value problems for Hamiltonian systems. +Arch. Rat. Mech. Anal. 78, 315--333 (1982) +\end{thebibliography} +\endgroup} diff --git a/doc/Rapport post-doc/longabstract.tex b/doc/Rapport post-doc/longabstract.tex new file mode 100644 index 0000000..1c90873 --- /dev/null +++ b/doc/Rapport post-doc/longabstract.tex @@ -0,0 +1,25 @@ +\section{Introduction} +\label{sec:intro} + + + + +% In the following, we first focus on the industrial needs of temporal +% properties that motivate our research. We then describe the +% representation languages to represent time as an intrinsic information +% of the system modelled, and their expressivity. On a simple study +% case, using constant-delays as the simplest timed interactions between +% elements of a system, we show how temporal properties are verified via +% the Tina model-checked, and how such analysis helps engineering design +% in its early-development phases. We conclude with a discussion on the +% state of the art, and comment on the future work and extensions of +% this approach. +% in AltaRica modelling language, and how an extended version of it +% allow us to express time intervals, where events occur +% non-deterministically. + + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "main" +%%% End: diff --git a/doc/Rapport post-doc/lstlang3.sty b/doc/Rapport post-doc/lstlang3.sty new file mode 100644 index 0000000..e415893 --- /dev/null +++ b/doc/Rapport post-doc/lstlang3.sty @@ -0,0 +1,1067 @@ +%% +%% This is file `lstlang3.sty', +%% generated with the docstrip utility. +%% +%% The original source files were: +%% +%% lstdrvrs.dtx (with options: `lang3') +%% +%% (w)(c) 1996/1997/1998/1999/2000/2001/2002/2003/2004 Carsten Heinz +%% and/or any other author listed elsewhere in this file. +%% +%% This file is distributed under the terms of the LaTeX Project Public +%% License from CTAN archives in directory macros/latex/base/lppl.txt. +%% Either version 1.0 or, at your option, any later version. +%% +%% This file is completely free and comes without any warranty. +%% +%% Send comments and ideas on the package, error reports and additional +%% programming languages to . +%% +\ProvidesFile{lstlang3.sty} + [2004/02/13 1.2 listings language file] + + +% Lignes vides moins espacées +\lst@AddToHook{OnEmptyLine}{\vskip -0.5ex} +%\lst@AddToHook{OnNewLine}{\vskip -0.5ex} + + + +\lst@definelanguage[68]{Algol}% + {morekeywords={abs,and,arg,begin,bin,bits,bool,by,bytes,case,channel,% + char,co,comment,compl,conj,divab,do,down,elem,elif,else,empty,% + end,entier,eq,esac,exit,false,fi,file,flex,for,format,from,ge,% + goto,gt,heap,if,im,in,int,is,isnt,le,leng,level,loc,long,lt,lwb,% + minusab,mod,modab,mode,ne,nil,not,od,odd,of,op,or,ouse,out,over,% + overab,par,plusab,plusto,pr,pragmat,prio,proc,re,real,ref,repr,% + round,sema,shl,short,shorten,shr,sign,skip,string,struct,then,% + timesab,to,true,union,up,upb,void,while},% + sensitive=f,% ??? + morecomment=[s]{\#}{\#},% + keywordcomment={co,comment}% + }[keywords,comments,keywordcomments]% +\lst@definelanguage[60]{Algol}% + {morekeywords={array,begin,Boolean,code,comment,div,do,else,end,% + false,for,goto,if,integer,label,own,power,procedure,real,step,% + string,switch,then,true,until,value,while},% + sensitive=f,% ??? + keywordcommentsemicolon={end}{else,end}{comment}% + }[keywords,keywordcomments]% +%% +%% x86masm definition (c) 2002 Andrew Zabolotny +%% +\lst@definelanguage[x86masm]{Assembler}% + {morekeywords={al,ah,ax,eax,bl,bh,bx,ebx,cl,ch,cx,ecx,dl,dh,dx,edx,% + si,esi,di,edi,bp,ebp,sp,esp,cs,ds,es,ss,fs,gs,cr0,cr1,cr2,cr3,% + db0,db1,db2,db3,db4,db5,db6,db7,tr0,tr1,tr2,tr3,tr4,tr5,tr6,tr7,% + st,aaa,aad,aam,aas,adc,add,and,arpl,bound,bsf,bsr,bswap,bt,btc,% + btr,bts,call,cbw,cdq,clc,cld,cli,clts,cmc,cmp,cmps,cmpsb,cmpsw,% + cmpsd,cmpxchg,cwd,cwde,daa,das,dec,div,enter,hlt,idiv,imul,in,% + inc,ins,int,into,invd,invlpg,iret,ja,jae,jb,jbe,jc,jcxz,jecxz,% + je,jg,jge,jl,jle,jna,jnae,jnb,jnbe,jnc,jne,jng,jnge,jnl,jnle,% + jno,jnp,jns,jnz,jo,jp,jpe,jpo,js,jz,jmp,lahf,lar,lea,leave,lgdt,% + lidt,lldt,lmsw,lock,lods,lodsb,lodsw,lodsd,loop,loopz,loopnz,% + loope,loopne,lds,les,lfs,lgs,lss,lsl,ltr,mov,movs,movsb,movsw,% + movsd,movsx,movzx,mul,neg,nop,not,or,out,outs,pop,popa,popad,% + popf,popfd,push,pusha,pushad,pushf,pushfd,rcl,rcr,rep,repe,% + repne,repz,repnz,ret,retf,rol,ror,sahf,sal,sar,sbb,scas,seta,% + setae,setb,setbe,setc,sete,setg,setge,setl,setle,setna,setnae,% + setnb,setnbe,setnc,setne,setng,setnge,setnl,setnle,setno,setnp,% + setns,setnz,seto,setp,setpe,setpo,sets,setz,sgdt,shl,shld,shr,% + shrd,sidt,sldt,smsw,stc,std,sti,stos,stosb,stosw,stosd,str,sub,% + test,verr,verw,wait,wbinvd,xadd,xchg,xlatb,xor,fabs,fadd,fbld,% + fbstp,fchs,fclex,fcom,fcos,fdecstp,fdiv,fdivr,ffree,fiadd,ficom,% + fidiv,fidivr,fild,fimul,fincstp,finit,fist,fisub,fisubr,fld,fld1,% + fldl2e,fldl2t,fldlg2,fldln2,fldpi,fldz,fldcw,fldenv,fmul,fnop,% + fpatan,fprem,fprem1,fptan,frndint,frstor,fsave,fscale,fsetpm,% + fsin,fsincos,fsqrt,fst,fstcw,fstenv,fstsw,fsub,fsubr,ftst,fucom,% + fwait,fxam,fxch,fxtract,fyl2x,fyl2xp1,f2xm1},% + morekeywords=[2]{.align,.alpha,assume,byte,code,comm,comment,.const,% + .cref,.data,.data?,db,dd,df,dosseg,dq,dt,dw,dword,else,end,endif,% + endm,endp,ends,eq,equ,.err,.err1,.err2,.errb,.errdef,.errdif,% + .erre,.erridn,.errnb,.errndef,.errnz,event,exitm,extrn,far,% + .fardata,.fardata?,fword,ge,group,gt,high,if,if1,if2,ifb,ifdef,% + ifdif,ife,ifidn,ifnb,ifndef,include,includelib,irp,irpc,label,% + .lall,le,length,.lfcond,.list,local,low,lt,macro,mask,mod,.model,% + name,ne,near,offset,org,out,page,proc,ptr,public,purge,qword,.% + radix,record,rept,.sall,seg,segment,.seq,.sfcond,short,size,% + .stack,struc,subttl,tbyte,.tfcond,this,title,type,.type,width,% + word,.xall,.xcref,.xlist},% + alsoletter=.,alsodigit=?,% + sensitive=f,% + morestring=[b]",% + morestring=[b]',% + morecomment=[l];% + }[keywords,comments,strings] +%% +%% Clean definition (c) 1999 Jos\'e Romildo Malaquias +%% +%% Clean 1.3 : some standard functional language: pure, lazy, +%% polymorphic type system, modules, type classes, +%% garbage collection, functions as first class citizens +%% +\lst@definelanguage{Clean}% + {otherkeywords={:,::,=,:==,=:,=>,->,<-,<-:,\{,\},\{|,|\},\#,\#!,|,\&,% + [,],!,.,\\\\,;,_},% + morekeywords={from,definition,implementation,import,module,system,% + case,code,if,in,let,let!,of,where,with,infix,infixl,infixr},% + morendkeywords={True,False,Start,Int,Real,Char,Bool,String,World,% + File,ProcId},% + sensitive,% + morecomment=[l]//,% missing comma: Markus Pahlow + morecomment=[n]{/*}{*/},% + morestring=[b]"% + }[keywords,comments,strings]% +\lst@definelanguage{Comal 80}% + {morekeywords={AND,AUTO,CASE,DATA,DEL,DIM,DIV,DO,ELSE,ENDCASE,ENDIF,% + ENDPROC,ENDWHILE,EOD,EXEC,FALSE,FOR,GOTO,IF,INPUT,INT,LIST,LOAD,% + MOD,NEW,NEXT,NOT,OF,OR,PRINT,PROC,RANDOM,RENUM,REPEAT,RND,RUN,% + SAVE,SELECT,STOP,TAB,THEN,TRUE,UNTIL,WHILE,ZONE},% + sensitive=f,% ??? + morecomment=[l]//,% + morestring=[d]"% + }[keywords,comments,strings]% +\lst@definelanguage{Elan}% + {morekeywords={ABS,AND,BOOL,CAND,CASE,CAT,COLUMNS,CONCR,CONJ,CONST,% + COR,DECR,DEFINES,DET,DIV,DOWNTO,ELIF,ELSE,END,ENDIF,ENDOP,% + ENDPACKET,ENDPROC,ENDREP,ENDSELECT,FALSE,FI,FILE,FOR,FROM,IF,% + INCR,INT,INV,LEAVE,LENGTH,LET,MOD,NOT,OF,OP,OR,OTHERWISE,PACKET,% + PROC,REAL,REP,REPEAT,ROW,ROWS,SELECT,SIGN,STRUCT,SUB,TEXT,THEN,% + TRANSP,TRUE,TYPE,UNTIL,UPTO,VAR,WHILE,WITH,XOR,% + maxint,sign,abs,min,max,random,initializerandom,subtext,code,% + replace,text,laenge,pos,compress,change,maxreal,smallreal,floor,% + pi,e,ln,log2,log10,sqrt,exp,tan,tand,sin,sind,cos,cosd,arctan,% + arctand,int,real,lastconversionok,put,putline,line,page,get,% + getline,input,output,sequentialfile,maxlinelaenge,reset,eof,% + close,complexzero,complexone,complexi,complex,realpart,imagpart,% + dphi,phi,vector,norm,replace,matrix,idn,row,column,sub,% + replacerow,replacecolumn,replaceelement,transp,errorsstop,stop},% + sensitive,% + morestring=[d]"% + }[keywords,strings]% +%% +%% Erlang definition (c) 2003 Daniel Gazard +%% +\lst@definelanguage{erlang}% + {morekeywords={abs,after,and,apply,atom,atom_to_list,band,binary,% + binary_to_list,binary_to_term,bor,bsl,bsr,bxor,case,catch,% + date,div,element,erase,end,exit,export,float,float_to_list,% + get,halt,hash,hd,if,info,import,integer,integer_to_list,% + length,link,list,list_to_atom,list_to_float,list_to_integer,% + list_to_tuple,module,node,nodes,now,of,or,pid,port,ports,% + processes,put,receive,reference,register,registered,rem,% + round,self,setelement,size,spawn,throw,time,tl,trace,trunc,% + tuple,tuple_to_list,unlink,unregister,whereis,error,false,% + infinity,nil,ok,true,undefined,when},% + otherkeywords={->,!,[,],\{,\},},% + morecomment=[l]\%,% + morestring=[b]",% + morestring=[b]'% + }[keywords,comments,strings]% +\lst@definelanguage{ksh} + {morekeywords={alias,awk,cat,echo,else,elif,fi,exec,exit,% + for,in,do,done,select,case,esac,while,until,function,% + time,export,cd,eval,fc,fg,kill,let,pwd,read,return,rm,% + glob,goto,history,if,logout,nice,nohup,onintr,repeat,sed,% + set,setenv,shift,source,switch,then,umask,unalias,% + unset,wait,@,env,argv,child,home,ignoreeof,noclobber,% + noglob,nomatch,path,prompt,shell,status,verbose,print,printf,% + sqrt,BEGIN,END},% + morecomment=[l]\#,% + morestring=[d]",% + morestring=[d]',% + morestring=[d]`% + }[keywords,comments,strings]% +\lst@definelanguage{Logo}% + {morekeywords={and,atan,arctan,both,break,bf,bl,butfirst,butlast,% + cbreak, close,co,continue,cos,count,clearscreen,cs,debquit,% + describe,diff,difference,ed,edit,either,emptyp,equalp,er,erase,% + errpause,errquit,fifp,filefprint,fifty,fileftype,fip,fileprint,% + fird,fileread,fity,filetype,fiwd,fileword,f,first,or,fp,fprint,% + fput,fty,ftype,full,fullscreen,go,bye,goodbye,gprop,greaterp,% + help,if,iff,iffalse,ift,iftrue,nth,item,keyp,llast,lessp,list,% + local,lput,make,max,maximum,memberp,memtrace,min,minimum,namep,% + not,numberp,oflush,openr,openread,openw,openwrite,op,output,% + pause,plist,pots,pow,pprop,pps,pr,print,product,quotient,random,% + rc,readchar,rl,readlist,remprop,repcount,repeat,request,rnd,run,% + se,sentence,sentencep,setc,setcolor,setipause,setqpause,po,show,% + sin,split,splitscreen,sqrt,stop,sum,test,text,textscreen,thing,% + to,tone,top,toplevel,type,untrace,wait,word,wordp,yaccdebug,is,% + mod,remainder,trace,zerop,back,bk,bto,btouch,fd,forward,fto,% + ftouch,getpen,heading,hit,hitoot,ht,hideturtle,loff,lampoff,lon,% + lampon,lt,left,lot,lotoot,lto,ltouch,penc,pencolor,pd,pendown,pe,% + penerase,penmode,pu,penup,px,penreverse,rt,right,rto,rtouch,% + scrunch,seth,setheading,setscrun,setscrunch,setxy,shownp,st,% + showturtle,towardsxy,clean,wipeclean,xcor,ycor,tur,turtle,% + display,dpy},% + sensitive=f% ??? + }[keywords]% +%% +%% MetaPost definition (c) 2003 Uwe Siart +%% +\lst@definelanguage{MetaPost}% + {morekeywords={abs,addto,ahangle,ahlength,and,angle,arclength,% + arctime,background,bbox,bboxmargin,beginfig,begingroup,beveled,% + black,blue,bluepart,boolean,bot,boxit,boxjoin,bpath,btex,% + buildcycle,butt,cc,ceiling,char,charcode,circleit,circmargin,% + clip,cm,color,controls,cosd,curl,currentpen,currentpicture,% + cutafter,cutbefore,cutdraw,cuttings,cycle,dashed,dashpattern,% + day,dd,decimal,decr,def,defaultdx,defaultdy,defaultfont,% + defaultpen,defaultscale,dir,direction,directionpoint,% + directiontime,ditto,div,dotlabel,dotlabels,dotprod,down,downto,% + draw,drawarrow,drawboxed,drawboxes,drawdblarrow,drawoptions,% + drawshadowed,drawunboxed,else,elseif,end,enddef,endfig,endfor,% + endgroup,epsilon,etex,evenly,exitif,exitunless,expr,extra,fi,% + fill,filldraw,fixpos,fixsize,floor,fontsize,for,forever,% + forsuffixes,fullcircle,getmid,green,greenpart,halfcircle,hex,% + hide,identity,if,in,incr,infinity,infont,input,interim,% + intersectionpoint,intersectiontimes,inverse,joinup,known,label,% + labeloffset,labels,left,length,let,lft,linecap,linejoin,llcorner,% + llft,loggingall,lrcorner,lrt,makepath,makepen,mark,max,mexp,% + mfplain,middlepoint,midpoint,min,mitered,miterlimit,mlog,mod,% + month,mp,mpx,mpxbreak,newinternal,normaldeviate,not,nullpicture,% + numeric,oct,odd,or,origin,pair,path,pausing,pen,pencircle,% + penoffset,pensquare,pic,pickup,picture,point,postcontrol,% + precontrol,primarydef,prologues,quartercircle,red,redpart,% + reflectedabout,reverse,right,rotated,rotatedaround,round,rounded,% + rt,save,scaled,secondarydef,self,setbounds,shifted,shipout,show,% + showdependencies,showstopping,showtoken,showvariable,sind,% + slanted,special,sqrt,squared,step,str,string,subpath,substring,% + tertiarydef,text,thelabel,time,top,tracingall,tracingcapsules,% + tracingchoices,tracingcommands,tracingequations,tracinglostchars,% + tracingmacros,tracingnone,tracingonline,tracingoutput,% + tracingrestores,tracingspecs,tracingstats,tracingtitles,% + transform,transformed,true,truecorners,ulcorner,ulft,undraw,% + unfill,unfilldraw,uniformdeviate,unitsquare,unitvector,unknown,% + until,up,upto,urcorner,urt,vardef,verbatimtex,whatever,white,% + withcolor,withdots,withpen,xpart,xscaled,xxpart,xypart,year,% + yscaled,yxpart,yypart,zscaled},% + sensitive,% + alsoother={0123456789$},% + morecomment=[l]\%,% + morestring=[s]"% + }[keywords,comments,strings]% +%% +%% Mizar definition (c) 2003 Adam Grabowski +%% +%% Mizar is freely available at URL www.mizar.org for the Linux x86, +%% Solaris x86, and Windows operating systems. +%% +\lst@definelanguage{Mizar}% + {otherkeywords={->,(\#,\#),.=),\&},% + morekeywords={vocabulary,constructors,$1,$1,$2,$3,$4,$5,$6,$7,$8,% + @proof,according,aggregate,and,antonym,as,associativity,assume,% + asymmetry,attr,be,begin,being,by,canceled,case,cases,cluster,% + clusters,coherence,commutativity,compatibility,connectedness,% + consider,consistency,constructors,contradiction,correctness,def,% + deffunc,define,definition,definitions,defpred,end,environ,equals,% + ex,exactly,existence,for,from,func,given,hence,hereby,holds,% + idempotence,if,iff,implies,involutiveness,irreflexivity,is,it,% + let,means,mode,non,not,notation,now,of,or,otherwise,over,per,% + pred,prefix,projectivity,proof,provided,qua,reconsider,redefine,% + reflexivity,requirements,reserve,scheme,schemes,section,selector,% + set,st,struct,such,suppose,symmetry,synonym,take,that,the,then,% + theorem,theorems,thesis,thus,to,transitivity,uniqueness,% + vocabulary,where},% + sensitive=t,% + morecomment=[l]::% + }[keywords,comments]% +\lst@definelanguage{Modula-2}% + {morekeywords={AND,ARRAY,BEGIN,BY,CASE,CONST,DIV,DO,ELSE,ELSIF,END,% + EXIT,EXPORT,FOR,FROM,IF,IMPLEMENTATION,IMPORT,IN,MOD,MODULE,NOT,% + OF,OR,POINTER,PROCEDURE,QUALIFIED,RECORD,REPEAT,RETURN,SET,THEN,% + TYPE,UNTIL,VAR,WHILE,WITH,ABS,BITSET,BOOLEAN,CAP,CARDINAL,CHAR,% + CHR,DEC,EXCL,FALSE,FLOAT,HALT,HIGH,INC,INCL,INTEGER,LONGCARD,% + LONGINT,LONGREAL,MAX,MIN,NIL,ODD,ORD,PROC,REAL,SIZE,TRUE,TRUNC,% + VAL,DEFINITION,LOOP},% added keywords due to Peter Bartke 99/07/22 + sensitive,% + morecomment=[n]{(*}{*)},% + morestring=[d]',% + morestring=[d]"% + }[keywords,comments,strings]% +\lstdefinelanguage{MuPAD}{% + morekeywords={end,next,break,if,then,elif,else,end_if,case,end_case,% + otherwise,for,from,to,step,downto,in,end_for,while,end_while,% + repeat,until,end_repeat,or,and,not,xor,div,mod,union,minus,% + intersect,subset,proc,begin,end_proc,domain,end_domain,category,% + end_category,axiom,end_axiom,quit,delete,frame},% + morekeywords=[2]{NIL,FAIL,TRUE,FALSE,UNKNOWN,I,RD_INF,RD_NINF,% + RD_NAN,name,local,option,save,inherits,of,do},% + otherkeywords={\%if,?,!,:=,<,>,=,<=,<>,>=,==>,<=>,::,..,...,->,% + @,@@,\$},% + sensitive=true,% + morecomment=[l]{//},% + morecomment=[n]{/*}{*/},% + morestring=[b]",% + morestring=[d]{`}% + }[keywords,comments,strings] +\lst@definelanguage{NASTRAN} + {morekeywords={ENDDATA},% + morecomment=[l]$,% + MoreSelectCharTable=% + \lst@CArgX BEGIN\ BULK\relax\lst@CDef{}% + {\lst@ifmode\else \ifnum\lst@length=\z@ + \lst@EnterMode{\lst@GPmode}{\lst@modetrue + \let\lst@currstyle\lst@gkeywords@sty}% + \fi \fi}% + {\ifnum\lst@mode=\lst@GPmode + \lst@XPrintToken \lst@LeaveMode + \fi}% + }[keywords,comments]% +\lst@definelanguage{Oberon-2}% + {morekeywords={ARRAY,BEGIN,BOOLEAN,BY,CASE,CHAR,CONST,DIV,DO,ELSE,% + ELSIF,END,EXIT,FALSE,FOR,IF,IMPORT,IN,INTEGER,IS,LONGINT,% + LONGREAL,LOOP,MOD,MODULE,NIL,OF,OR,POINTER,PROCEDURE,REAL,RECORD,% + REPEAT,RETURN,SET,SHORTINT,THEN,TO,TRUE,TYPE,UNTIL,VAR,WHILE,% + WITH,ABS,ASH,CAP,CHR,COPY,DEC,ENTIER,EXCL,HALT,INC,INCL,LEN,LONG,% + MAX,MIN,NEW,ODD,ORD,SHORT,SIZE},% + sensitive,% + morecomment=[n]{(*}{*)},% + morestring=[d]',% + morestring=[d]"% + }[keywords,comments,strings]% +%% +%% OCL definition (c) 2000 Achim D. Brucker +%% +%% You are allowed to use, modify and distribute this code either under +%% the terms of the LPPL (version 1.0 or later) or the GPL (version 2.0 +%% or later). +%% +\lst@definelanguage[decorative]{OCL}[OMG]{OCL} + {otherkeywords={@pre},% + morendkeywords={name,attributes,associatoinEnds,operations,% + supertypes,allSupertypes,allInstances,oclIsKindOf,oclIsTypeOf,% + oclAsType,oclInState,oclIsNew,evaluationType,abs,floor,round,max,% + min,div,mod,size,concat,toUpper,toLower,substring,includes,% + excludes,count,includesAll,exludesAll,isEmpty,notEmpty,sum,% + exists,forAll,isUnique,sortedBy,iterate,union,intersection,% + including,excluding,symmetricDifference,select,reject,collect,% + asSequence,asBag,asSequence,asSet,append,prepend,subSequence,at,% + first,last,true,false,isQuery}% + }% +\lst@definelanguage[OMG]{OCL}% + {morekeywords={context,pre,inv,post},% + ndkeywords={or,xor,and,not,implies,if,then,else,endif},% + morekeywords=[3]{Boolean,Integer,Real,String,Set,Sequence,Bag,% + OclType,OclAny,OclExpression,Enumeration,Collection,},% + sensitive=t,% + morecomment=[l]--,% + morestring=[d]'% + }[keywords,comments,strings]% +\lst@definelanguage{PL/I}% + {morekeywords={ABS,ATAN,AUTOMATIC,AUTO,ATAND,BEGIN,BINARY,BIN,BIT,% + BUILTIN,BY,CALL,CHARACTER,CHAR,CHECK,COLUMN,COL,COMPLEX,CPLX,% + COPY,COS,COSD,COSH,DATA,DATE,DECIMAL,DEC,DECLARE,DCL,DO,EDIT,% + ELSE,END,ENDFILE,ENDPAGE,ENTRY,EXP,EXTERNAL,EXT,FINISH,FIXED,% + FIXEDOVERFLOW,FOFL,FLOAT,FORMAT,GET,GO,GOTO,IF,IMAG,INDEX,% + INITIAL,INIT,INTERNAL,INT,LABEL,LENGTH,LIKE,LINE,LIST,LOG,LOG2,% + LOG10,MAIN,MAX,MIN,MOD,NOCHECK,NOFIXEDOVERFLOW,NOFOFL,NOOVERFLOW,% + NOOFL,NOSIZE,NOUNDERFLOW,NOUFL,NOZERODIVIDE,NOZDIV,ON,OPTIONS,% + OVERFLOW,OFL,PAGE,PICTURE,PROCEDURE,PROC,PUT,READ,REPEAT,RETURN,% + RETURNS,ROUND,SIN,SIND,SINH,SIZE,SKIP,SQRT,STATIC,STOP,STRING,% + SUBSTR,SUM,SYSIN,SYSPRINT,TAN,TAND,TANH,THEN,TO,UNDERFLOW,UFL,% + VARYING,WHILE,WRITE,ZERODIVIDE,ZDIV},% + sensitive=f,% + morecomment=[s]{/*}{*/},% + morestring=[d]'% + }[keywords,comments,strings]% +%% +%% Reduce definition (c) 2002 Geraint Paul Bevan +%% +\lst@definelanguage{Reduce}% + {morekeywords={% +%% reserved identifiers +abs,acos,acosh,acot,acoth,acsc,acsch,% +adjprec,algebraic,algint,allbranch,allfac,and,% +antisymmetric,append,arglength,array,asec,asech,% +asin,asinh,atan,atan2,atanh,begin,bfspace,bye,% +card_no,ceiling,clear,clearrules,coeff,coeffn,% +cofactor,combineexpt,combinelogs,comment,comp,% +complex,conj,cons,cont,cos,cosh,cot,coth,cramer,% +cref,csc,csch,decompose,define,defn,deg,demo,den,% +depend,det,df,difference,dilog,display,div,do,e,% +echo,ed,editdef,ei,end,eps,eq,equal,erf,errcont,% +evallhseqp,eval_mode,even,evenp,exp,expandlogs,% +expr,expt,ezgcd,factor,factorial,factorize,fexpr,% +first,fix,fixp,floor,for,forall,foreach,fort,% +fort_width,freeof,fullroots,g,gcd,geq,go,goto,% +greaterp,high_pow,hypot,i,if,ifactor,impart,in,% +index,infinity,infix,input,int,integer,interpol,% +intstr,k,korder,lambda,lcm,lcof,length,leq,lessp,% +let,lhs,linear,linelength,lisp,list,listargp,% +listargs,ln,load,load_package,log,log10,logb,% +low_pow,lterm,macro,mainvar,mass,mat,match,% +mateigen,matrix,max,mcd,member,memq,min,minus,mkid,% +modular,msg,mshell,multiplicities,nat,neq,nero,% +nextprime,nil,nodepend,noncom,nonzero,nosplit,% +nospur,nullspace,num,numberp,odd,off,on,operator,% +or,order,ordp,out,output,part,pause,period,pf,pi,% +plus,precedence,precise,precision,pret,pri,primep,% +print_precision,procedure,product,quit,quotient,% +random,random_new_seed,rank,rat,ratarg,rational,% +rationalize,ratpri,real,rederr,reduct,remainder,% +remfac,remind,repart,repeat,rest,resultant,retry,% +return,reverse,revpri,rhs,rlisp88,% +root_multiplicity,round,roundall,roundbf,rounded,% +saveas,savestructr,scalar,sec,sech,second,set,% +setmod,setq,share,showrules,showtime,shut,sign,sin,% +sinh,smacro,solve,solvesingular,spur,sqrt,structr,% +sub,sum,symbolic,symmetric,t,tan,tanh,third,time,% +times,tp,tra,trace,trfac,trigform,trint,until,% +varname,vecdim,vector,weight,when,where,while,% +write,ws,wtlevel,% +%% identifiers with spaces +%% for all,for each,go to,such that,% +},% + sensitive=false,% + morecomment=[l]\%,% + morecomment=[s]{COMMENT}{;},% + morecomment=[s]{COMMENT}{$},% + morestring="% + }[keywords,comments,strings]% +\lst@definelanguage[IBM]{Simula}[DEC]{Simula}{}% +\lst@definelanguage[DEC]{Simula}[67]{Simula}% + {morekeywords={and,eq,eqv,ge,gt,hidden,imp,le,long,lt,ne,not,% + options,or,protected,short}% + }% +\lst@definelanguage[CII]{Simula}[67]{Simula}% + {morekeywords={and,equiv,exit,impl,not,or,stop}}% +\lst@definelanguage[67]{Simula}% + {morekeywords={activate,after,array,at,before,begin,boolean,% + character,class,comment,delay,detach,do,else,end,external,false,% + for,go,goto,if,in,inner,inspect,integer,is,label,name,new,none,% + notext,otherwise,prior,procedure,qua,reactivate,real,ref,resume,% + simset,simulation,step,switch,text,then,this,to,true,until,value,% + virtual,when,while},% + sensitive=f,% + keywordcommentsemicolon={end}{else,end,otherwise,when}{comment},% + morestring=[d]",% + morestring=[d]'% + }[keywords,keywordcomments,strings]% +\lst@definelanguage{S}[]{R}{} +\lst@definelanguage[PLUS]{S}[]{R}{} +\lst@definelanguage{R}% + {keywords={abbreviate,abline,abs,acos,acosh,action,add1,add,% + aggregate,alias,Alias,alist,all,anova,any,aov,aperm,append,apply,% + approx,approxfun,apropos,Arg,args,array,arrows,as,asin,asinh,% + atan,atan2,atanh,attach,attr,attributes,autoload,autoloader,ave,% + axis,backsolve,barplot,basename,besselI,besselJ,besselK,besselY,% + beta,binomial,body,box,boxplot,break,browser,bug,builtins,bxp,by,% + c,C,call,Call,case,cat,category,cbind,ceiling,character,char,% + charmatch,check,chol,chol2inv,choose,chull,class,close,cm,codes,% + coef,coefficients,co,col,colnames,colors,colours,commandArgs,% + comment,complete,complex,conflicts,Conj,contents,contour,% + contrasts,contr,control,helmert,contrib,convolve,cooks,coords,% + distance,coplot,cor,cos,cosh,count,fields,cov,covratio,wt,CRAN,% + create,crossprod,cummax,cummin,cumprod,cumsum,curve,cut,cycle,D,% + data,dataentry,date,dbeta,dbinom,dcauchy,dchisq,de,debug,% + debugger,Defunct,default,delay,delete,deltat,demo,de,density,% + deparse,dependencies,Deprecated,deriv,description,detach,% + dev2bitmap,dev,cur,deviance,off,prev,,dexp,df,dfbetas,dffits,% + dgamma,dgeom,dget,dhyper,diag,diff,digamma,dim,dimnames,dir,% + dirname,dlnorm,dlogis,dnbinom,dnchisq,dnorm,do,dotplot,double,% + download,dpois,dput,drop,drop1,dsignrank,dt,dummy,dump,dunif,% + duplicated,dweibull,dwilcox,dyn,edit,eff,effects,eigen,else,% + emacs,end,environment,env,erase,eval,equal,evalq,example,exists,% + exit,exp,expand,expression,External,extract,extractAIC,factor,% + fail,family,fft,file,filled,find,fitted,fivenum,fix,floor,for,% + For,formals,format,formatC,formula,Fortran,forwardsolve,frame,% + frequency,ftable,ftable2table,function,gamma,Gamma,gammaCody,% + gaussian,gc,gcinfo,gctorture,get,getenv,geterrmessage,getOption,% + getwd,gl,glm,globalenv,gnome,GNOME,graphics,gray,grep,grey,grid,% + gsub,hasTsp,hat,heat,help,hist,home,hsv,httpclient,I,identify,if,% + ifelse,Im,image,\%in\%,index,influence,measures,inherits,install,% + installed,integer,interaction,interactive,Internal,intersect,% + inverse,invisible,IQR,is,jitter,kappa,kronecker,labels,lapply,% + layout,lbeta,lchoose,lcm,legend,length,levels,lgamma,library,% + licence,license,lines,list,lm,load,local,locator,log,log10,log1p,% + log2,logical,loglin,lower,lowess,ls,lsfit,lsf,ls,machine,Machine,% + mad,mahalanobis,make,link,margin,match,Math,matlines,mat,matplot,% + matpoints,matrix,max,mean,median,memory,menu,merge,methods,min,% + missing,Mod,mode,model,response,mosaicplot,mtext,mvfft,na,nan,% + names,omit,nargs,nchar,ncol,NCOL,new,next,NextMethod,nextn,% + nlevels,nlm,noquote,NotYetImplemented,NotYetUsed,nrow,NROW,null,% + numeric,\%o\%,objects,offset,old,on,Ops,optim,optimise,optimize,% + options,or,order,ordered,outer,package,packages,page,pairlist,% + pairs,palette,panel,par,parent,parse,paste,path,pbeta,pbinom,% + pcauchy,pchisq,pentagamma,persp,pexp,pf,pgamma,pgeom,phyper,pico,% + pictex,piechart,Platform,plnorm,plogis,plot,pmatch,pmax,pmin,% + pnbinom,pnchisq,pnorm,points,poisson,poly,polygon,polyroot,pos,% + postscript,power,ppoints,ppois,predict,preplot,pretty,Primitive,% + print,prmatrix,proc,prod,profile,proj,prompt,prop,provide,% + psignrank,ps,pt,ptukey,punif,pweibull,pwilcox,q,qbeta,qbinom,% + qcauchy,qchisq,qexp,qf,qgamma,qgeom,qhyper,qlnorm,qlogis,qnbinom,% + qnchisq,qnorm,qpois,qqline,qqnorm,qqplot,qr,Q,qty,qy,qsignrank,% + qt,qtukey,quantile,quasi,quit,qunif,quote,qweibull,qwilcox,% + rainbow,range,rank,rbeta,rbind,rbinom,rcauchy,rchisq,Re,read,csv,% + csv2,fwf,readline,socket,real,Recall,rect,reformulate,regexpr,% + relevel,remove,rep,repeat,replace,replications,report,require,% + resid,residuals,restart,return,rev,rexp,rf,rgamma,rgb,rgeom,R,% + rhyper,rle,rlnorm,rlogis,rm,rnbinom,RNGkind,rnorm,round,row,% + rownames,rowsum,rpois,rsignrank,rstandard,rstudent,rt,rug,runif,% + rweibull,rwilcox,sample,sapply,save,scale,scan,scan,screen,sd,se,% + search,searchpaths,segments,seq,sequence,setdiff,setequal,set,% + setwd,show,sign,signif,sin,single,sinh,sink,solve,sort,source,% + spline,splinefun,split,sqrt,stars,start,stat,stem,step,stop,% + storage,strstrheight,stripplot,strsplit,structure,strwidth,sub,% + subset,substitute,substr,substring,sum,summary,sunflowerplot,svd,% + sweep,switch,symbol,symbols,symnum,sys,status,system,t,table,% + tabulate,tan,tanh,tapply,tempfile,terms,terrain,tetragamma,text,% + time,title,topo,trace,traceback,transform,tri,trigamma,trunc,try,% + ts,tsp,typeof,unclass,undebug,undoc,union,unique,uniroot,unix,% + unlink,unlist,unname,untrace,update,upper,url,UseMethod,var,% + variable,vector,Version,vi,warning,warnings,weighted,weights,% + which,while,window,write,\%x\%,x11,X11,xedit,xemacs,xinch,xor,% + xpdrows,xy,xyinch,yinch,zapsmall,zip},% + otherkeywords={!,!=,~,$,*,\&,\%/\%,\%*\%,\%\%,<-,<<-,_,/},% + alsoother={._$},% + sensitive,% + morecomment=[l]\#,% + morestring=[d]",% + morestring=[d]'% 2001 Robert Denham + }% +\lst@definelanguage{SAS}% + {procnamekeys={proc},% + morekeywords={DATA,AND,OR,NOT,EQ,GT,LT,GE,LE,NE,INFILE,INPUT,DO,BY,% + TO,SIN,COS,OUTPUT,END,PLOT,RUN,LIBNAME,VAR,TITLE,FIRSTOBS,OBS,% + DELIMITER,DLM,EOF,ABS,DIM,HBOUND,LBOUND,MAX,MIN,MOD,SIGN,SQRT,% + CEIL,FLOOR,FUZZ,INT,ROUND,TRUNC,DIGAMMA,ERF,ERFC,EXP,GAMMA,% + LGAMMA,LOG,LOG2,LOG10,ARCOS,ARSIN,ATAN,COSH,SINH,TANH,TAN,% + POISSON,PROBBETA,PROBBNML,PROBCHI,PROBF,PROBGAM,PROBHYPR,% + PROBNEGB,PROBNORM,PROBT,BETAINV,CINV,FINV,GAMINV,PROBIT,TINV,CSS,% + CV,KURTOSIS,MEAN,NMISS,RANGE,SKEWNESS,STD,STDERR,SUM,USS,NORMAL,% + RANBIN,RANCAU,RANEXP,RANGAM,RANNOR,RANPOI,RANTBL,RANTRI,RANUNI,% + UNIFORM,IF,THEN,ELSE,WHILE,UNTIL,DROP,KEEP,LABEL,DEFAULT,ARRAY,% + MERGE,CARDS,CARDS4,PUT,SET,UPDATE,ABORT,DELETE,DISPLAY,LIST,% + LOSTCARD,MISSING,STOP,WHERE,ARRAY,DROP,KEEP,WINDOW,LENGTH,RENAME,% + RETAIN,MEANS,UNIVARIATE,SUMMARY,TABULATE,CORR,FREQ,FOOTNOTE,NOTE,% + SHOW},% + otherkeywords={!,!=,~,$,*,\&,_,/,<,>=,=<,>},% + morestring=[d]'% + }[keywords,comments,strings,procnames]% +\lst@definelanguage[AlLaTeX]{TeX}[LaTeX]{TeX}% + {moretexcs={AtBeginDocument,AtBeginDvi,AtEndDocument,AtEndOfClass,% + AtEndOfPackage,ClassError,ClassInfo,ClassWarning,% + ClassWarningNoLine,CurrentOption,DeclareErrorFont,% + DeclareFixedFont,DeclareFontEncoding,DeclareFontEncodingDefaults,% + DeclareFontFamily,DeclareFontShape,DeclareFontSubstitution,% + DeclareMathAccent,DeclareMathAlphabet,DeclareMathAlphabet,% + DeclareMathDelimiter,DeclareMathRadical,DeclareMathSizes,% + DeclareMathSymbol,DeclareMathVersion,DeclareOldFontCommand,% + DeclareOption,DeclarePreloadSizes,DeclareRobustCommand,% + DeclareSizeFunction,DeclareSymbolFont,DeclareSymbolFontAlphabet,% + DeclareTextAccent,DeclareTextAccentDefault,DeclareTextCommand,% + DeclareTextCommandDefault,DeclareTextComposite,% + DeclareTextCompositeCommand,DeclareTextFontCommand,% + DeclareTextSymbol,DeclareTextSymbolDefault,ExecuteOptions,% + GenericError,GenericInfo,GenericWarning,IfFileExists,% + InputIfFileExists,LoadClass,LoadClassWithOptions,MessageBreak,% + OptionNotUsed,PackageError,PackageInfo,PackageWarning,% + PackageWarningNoLine,PassOptionsToClass,PassOptionsToPackage,% + ProcessOptionsProvidesClass,ProvidesFile,ProvidesFile,% + ProvidesPackage,ProvideTextCommand,RequirePackage,% + RequirePackageWithOptions,SetMathAlphabet,SetSymbolFont,% + TextSymbolUnavailable,UseTextAccent,UseTextSymbol},% + morekeywords={array,center,displaymath,document,enumerate,eqnarray,% + equation,flushleft,flushright,itemize,list,lrbox,math,minipage,% + picture,sloppypar,tabbing,tabular,trivlist,verbatim}% + }% +\lst@definelanguage[LaTeX]{TeX}[common]{TeX}% + {moretexcs={a,AA,aa,addcontentsline,addpenalty,addtocontents,% + addtocounter,addtolength,addtoversion,addvspace,alph,Alph,and,% + arabic,array,arraycolsep,arrayrulewidth,arraystretch,author,% + baselinestretch,begin,bezier,bfseries,bibcite,bibdata,bibitem,% + bibliography,bibliographystyle,bibstyle,bigskip,boldmath,% + botfigrule,bottomfraction,Box,caption,center,CheckCommand,circle,% + citation,cite,cleardoublepage,clearpage,cline,columnsep,% + columnseprule,columnwidth,contentsline,dashbox,date,dblfigrule,% + dblfloatpagefraction,dblfloatsep,dbltextfloatsep,dbltopfraction,% + defaultscriptratio,defaultscriptscriptratio,depth,Diamond,% + displaymath,document,documentclass,documentstyle,doublerulesep,% + em,emph,endarray,endcenter,enddisplaymath,enddocument,% + endenumerate,endeqnarray,endequation,endflushleft,endflushright,% + enditemize,endlist,endlrbox,endmath,endminipage,endpicture,% + endsloppypar,endtabbing,endtabular,endtrivlist,endverbatim,% + enlargethispage,ensuremath,enumerate,eqnarray,equation,% + evensidemargin,extracolsep,fbox,fboxrule,fboxsep,filecontents,% + fill,floatpagefraction,floatsep,flushbottom,flushleft,flushright,% + fnsymbol,fontencoding,fontfamily,fontseries,fontshape,fontsize,% + fontsubfuzz,footnotemark,footnotesep,footnotetext,footskip,frac,% + frame,framebox,fussy,glossary,headheight,headsep,height,hline,% + hspace,I,include,includeonly,index,inputlineno,intextsep,% + itemindent,itemize,itemsep,iterate,itshape,Join,kill,label,% + labelsep,labelwidth,LaTeX,LaTeXe,leadsto,lefteqn,leftmargin,% + leftmargini,leftmarginii,leftmarginiii,leftmarginiv,leftmarginv,% + leftmarginvi,leftmark,lhd,lim,linebreak,linespread,linethickness,% + linewidth,list,listfiles,listfiles,listparindent,lrbox,% + makeatletter,makeatother,makebox,makeglossary,makeindex,% + makelabel,MakeLowercase,MakeUppercase,marginpar,marginparpush,% + marginparsep,marginparwidth,markboth,markright,math,mathbf,% + mathellipsis,mathgroup,mathit,mathrm,mathsf,mathsterling,mathtt,% + mathunderscore,mathversion,mbox,mdseries,mho,minipage,% + multicolumn,multiput,NeedsTeXFormat,newcommand,newcounter,% + newenvironment,newfont,newhelp,newlabel,newlength,newline,% + newmathalphabet,newpage,newsavebox,newtheorem,nobreakspace,% + nobreakspace,nocite,nocorr,nocorrlist,nofiles,nolinebreak,% + nonumber,nopagebreak,normalcolor,normalfont,normalmarginpar,% + numberline,obeycr,oddsidemargin,oldstylenums,onecolumn,oval,% + pagebreak,pagenumbering,pageref,pagestyle,paperheight,paperwidth,% + paragraphmark,parbox,parsep,partopsep,picture,poptabs,pounds,% + protect,pushtabs,put,qbezier,qbeziermax,r,raggedleft,raisebox,% + ref,refstepcounter,renewcommand,renewenvironment,restorecr,% + reversemarginpar,rhd,rightmargin,rightmark,rmfamily,roman,Roman,% + rootbox,rule,samepage,sbox,scshape,secdef,section,sectionmark,% + selectfont,setcounter,settodepth,settoheight,settowidth,sffamily,% + shortstack,showoutput,showoverfull,sloppy,sloppypar,slshape,% + smallskip,sqsubset,sqsupset,SS,stackrel,stepcounter,stop,stretch,% + subparagraphmark,subsectionmark,subsubsectionmark,sum,% + suppressfloats,symbol,tabbing,tabbingsep,tabcolsep,tabular,% + tabularnewline,textasciicircum,textasciitilde,textbackslash,% + textbar,textbf,textbraceleft,textbraceright,textbullet,% + textcircled,textcompwordmark,textdagger,textdaggerdbl,textdollar,% + textellipsis,textemdash,textendash,textexclamdown,textfloatsep,% + textfraction,textgreater,textheight,textit,textless,textmd,% + textnormal,textparagraph,textperiodcentered,textquestiondown,% + textquotedblleft,textquotedblright,textquoteleft,textquoteright,% + textregistered,textrm,textsc,textsection,textsf,textsl,% + textsterling,textsuperscript,texttrademark,texttt,textunderscore,% + textup,textvisiblespace,textwidth,thanks,thefootnote,thempfn,% + thempfn,thempfootnote,thepage,thepage,thicklines,thinlines,% + thispagestyle,title,today,topfigrule,topfraction,topmargin,% + topsep,totalheight,tracingfonts,trivlist,ttfamily,twocolumn,% + typein,typeout,unboldmath,unitlength,unlhd,unrhd,upshape,usebox,% + usecounter,usefont,usepackage,value,vector,verb,verbatim,vline,% + vspace,width,% + normalsize,small,footnotesize,scriptsize,tiny,large,Large,LARGE,% + huge,Huge}% + }% +\lst@definelanguage[plain]{TeX}[common]{TeX}% + {moretexcs={advancepageno,beginsection,bf,bffam,bye,cal,cleartabs,% + columns,dosupereject,endinsert,eqalign,eqalignno,fiverm,fivebf,% + fivei,fivesy,folio,footline,hang,headline,it,itemitem,itfam,% + leqalignno,magnification,makefootline,makeheadline,midinsert,mit,% + mscount,nopagenumbers,normalbottom,of,oldstyle,pagebody,% + pagecontents,pageinsert,pageno,plainoutput,preloaded,proclaim,rm,% + settabs,sevenbf,seveni,sevensy,sevenrm,sl,slfam,supereject,% + tabalign,tabs,tabsdone,tabsyet,tenbf,tenex,teni,tenit,tenrm,% + tensl,tensy,tentt,textindent,topglue,topins,topinsert,tt,ttfam,% + ttraggedright,vfootnote}% + }% +\lst@definelanguage[common]{TeX}[primitive]{TeX} + {moretexcs={active,acute,ae,AE,aleph,allocationnumber,allowbreak,% + alpha,amalg,angle,approx,arccos,arcsin,arctan,arg,arrowvert,% + Arrowvert,ast,asymp,b,backslash,bar,beta,bgroup,big,Big,bigbreak,% + bigcap,bigcirc,bigcup,bigg,Bigg,biggl,Biggl,biggm,Biggm,biggr,% + Biggr,bigl,Bigl,bigm,Bigm,bigodot,bigoplus,bigotimes,bigr,Bigr,% + bigskip,bigskipamount,bigsqcup,bigtriangledown,bigtriangleup,% + biguplus,bigvee,bigwedge,bmod,bordermatrix,bot,bowtie,brace,% + braceld,bracelu,bracerd,braceru,bracevert,brack,break,breve,% + buildrel,bullet,c,cap,cases,cdot,cdotp,cdots,centering,% + centerline,check,chi,choose,circ,clubsuit,colon,cong,coprod,% + copyright,cos,cosh,cot,coth,csc,cup,d,dag,dagger,dashv,ddag,% + ddagger,ddot,ddots,deg,delta,Delta,det,diamond,diamondsuit,dim,% + displaylines,div,do,dospecials,dot,doteq,dotfill,dots,downarrow,% + Downarrow,downbracefill,egroup,eject,ell,empty,emptyset,endgraf,% + endline,enskip,enspace,epsilon,equiv,eta,exists,exp,filbreak,% + flat,fmtname,fmtversion,footins,footnote,footnoterule,forall,% + frenchspacing,frown,gamma,Gamma,gcd,ge,geq,gets,gg,goodbreak,% + grave,H,hat,hbar,heartsuit,hglue,hideskip,hidewidth,hom,% + hookleftarrow,hookrightarrow,hphantom,hrulefill,i,ialign,iff,Im,% + imath,in,inf,infty,int,interdisplaylinepenalty,% + interfootnotelinepenalty,intop,iota,item,j,jmath,joinrel,jot,% + kappa,ker,l,L,lambda,Lambda,land,langle,lbrace,lbrack,lceil,% + ldotp,ldots,le,leavevmode,leftarrow,Leftarrow,leftarrowfill,% + leftharpoondown,leftharpoonup,leftline,leftrightarrow,% + Leftrightarrow,leq,lfloor,lg,lgroup,lhook,lim,liminf,limsup,line,% + ll,llap,lmoustache,ln,lnot,log,longleftarrow,Longleftarrow,% + longleftrightarrow,Longleftrightarrow,longmapsto,longrightarrow,% + Longrightarrow,loop,lor,lq,magstep,magstep,magstephalf,mapsto,% + mapstochar,mathhexbox,mathpalette,mathstrut,matrix,max,maxdimen,% + medbreak,medskip,medskipamount,mid,min,models,mp,mu,multispan,% + nabla,narrower,natural,ne,nearrow,neg,negthinspace,neq,newbox,% + newcount,newdimen,newfam,newif,newinsert,newlanguage,newmuskip,% + newread,newskip,newtoks,newwrite,next,ni,nobreak,nointerlineskip,% + nonfrenchspacing,normalbaselines,normalbaselineskip,% + normallineskip,normallineskiplimit,not,notin,nu,null,nwarrow,o,O,% + oalign,obeylines,obeyspaces,odot,oe,OE,offinterlineskip,oint,% + ointop,omega,Omega,ominus,ooalign,openup,oplus,oslash,otimes,% + overbrace,overleftarrow,overrightarrow,owns,P,parallel,partial,% + perp,phantom,phi,Phi,pi,Pi,pm,pmatrix,pmod,Pr,prec,preceq,prime,% + prod,propto,psi,Psi,qquad,quad,raggedbottom,raggedright,rangle,% + rbrace,rbrack,rceil,Re,relbar,Relbar,removelastskip,repeat,% + rfloor,rgroup,rho,rhook,rightarrow,Rightarrow,rightarrowfill,% + rightharpoondown,rightharpoonup,rightleftharpoons,rightline,rlap,% + rmoustache,root,rq,S,sb,searrow,sec,setminus,sharp,showhyphens,% + sigma,Sigma,sim,simeq,sin,sinh,skew,slash,smallbreak,smallint,% + smallskip,smallskipamount,smash,smile,sp,space,spadesuit,sqcap,% + sqcup,sqrt,sqsubseteq,sqsupseteq,ss,star,strut,strutbox,subset,% + subseteq,succ,succeq,sum,sup,supset,supseteq,surd,swarrow,t,tan,% + tanh,tau,TeX,theta,Theta,thinspace,tilde,times,to,top,tracingall,% + triangle,triangleleft,triangleright,u,underbar,underbrace,% + uparrow,Uparrow,upbracefill,updownarrow,Updownarrow,uplus,% + upsilon,Upsilon,v,varepsilon,varphi,varpi,varrho,varsigma,% + vartheta,vdash,vdots,vec,vee,vert,Vert,vglue,vphantom,wedge,% + widehat,widetilde,wlog,wp,wr,xi,Xi,zeta}% + }% +\lst@definelanguage[primitive]{TeX}% + {moretexcs={above,abovedisplayshortskip,abovedisplayskip,aftergroup,% + abovewithdelims,accent,adjdemerits,advance,afterassignment,atop,% + atopwithdelims,badness,baselineskip,batchmode,begingroup,% + belowdisplayshortskip,belowdisplayskip,binoppenalty,botmark,box,% + boxmaxdepth,brokenpenalty,catcode,char,chardef,cleaders,closein,% + closeout,clubpenalty,copy,count,countdef,cr,crcr,csname,day,% + deadcycles,def,defaulthyphenchar,defaultskewchar,delcode,% + delimiter,delimiterfactor,delimitershortfall,dimen,dimendef,% + discretionary,displayindent,displaylimits,displaystyle,% + displaywidowpenalty,displaywidth,divide,doublehyphendemerits,dp,% + edef,else,emergencystretch,end,endcsname,endgroup,endinput,% + endlinechar,eqno,errhelp,errmessage,errorcontextlines,% + errorstopmode,escapechar,everycr,everydisplay,everyhbox,everyjob,% + everymath,everypar,everyvbox,exhyphenpenalty,expandafter,fam,fi,% + finalhypendemerits,firstmark,floatingpenalty,font,fontdimen,% + fontname,futurelet,gdef,global,globaldefs,halign,hangafter,% + hangindent,hbadness,hbox,hfil,hfill,hfilneg,hfuzz,hoffset,% + holdinginserts,hrule,hsize,hskip,hss,ht,hyphenation,hyphenchar,% + hyphenpenalty,if,ifcase,ifcat,ifdim,ifeof,iffalse,ifhbox,ifhmode,% + ifinner,ifmmode,ifnum,ifodd,iftrue,ifvbox,ifvmode,ifvoid,ifx,% + ignorespaces,immediate,indent,input,insert,insertpenalties,% + interlinepenalty,jobname,kern,language,lastbox,lastkern,% + lastpenalty,lastskip,lccode,leaders,left,lefthyphenmin,leftskip,% + leqno,let,limits,linepenalty,lineskip,lineskiplimits,long,% + looseness,lower,lowercase,mag,mark,mathaccent,mathbin,mathchar,% + mathchardef,mathchoice,mathclose,mathcode,mathinner,mathop,% + mathopen,mathord,mathpunct,mathrel,mathsurround,maxdeadcycles,% + maxdepth,meaning,medmuskip,message,mkern,month,moveleft,% + moveright,mskip,multiply,muskip,muskipdef,newlinechar,noalign,% + noboundary,noexpand,noindent,nolimits,nonscript,nonstopmode,% + nulldelimiterspace,nullfont,number,omit,openin,openout,or,outer,% + output,outputpenalty,over,overfullrule,overline,overwithdelims,% + pagedepth,pagefilllstretch,pagefillstretch,pagefilstretch,% + pagegoal,pageshrink,pagestretch,pagetotal,par,parfillskip,% + parindent,parshape,parskip,patterns,pausing,penalty,% + postdisplaypenalty,predisplaypenalty,predisplaysize,pretolerance,% + prevdepth,prevgraf,radical,raise,read,relax,relpenalty,right,% + righthyphenmin,rightskip,romannumeral,scriptfont,% + scriptscriptfont,scriptscriptstyle,scriptspace,scriptstyle,% + scrollmode,setbox,setlanguage,sfcode,shipout,show,showbox,% + showboxbreadth,showboxdepth,showlists,showthe,skewchar,skip,% + skipdef,spacefactor,spaceskip,span,special,splitbotmark,% + splitfirstmark,splitmaxdepth,splittopskip,string,tabskip,% + textfont,textstyle,the,thickmuskip,thinmuskip,time,toks,toksdef,% + tolerance,topmark,topskip,tracingcommands,tracinglostchars,% + tracingmacros,tracingonline,tracingoutput,tracingpages,% + tracingparagraphs,tracingrestores,tracingstats,uccode,uchyph,% + underline,unhbox,unhcopy,unkern,unpenalty,unskip,unvbox,unvcopy,% + uppercase,vadjust,valign,vbadness,vbox,vcenter,vfil,vfill,% + vfilneg,vfuzz,voffset,vrule,vsize,vskip,vsplit,vss,vtop,wd,% + widowpenalty,write,xdef,xleaders,xspaceskip,year},% + sensitive,% + alsoother={0123456789$_},% + morecomment=[l]\%% + }[keywords,tex,comments]% +%% +%% Verilog definition (c) 2003 Cameron H. G. Wright +%% Based on the IEEE 1364-2001 Verilog HDL standard +%% Ref: S. Palnitkar, "Verilog HDL: A Guide to Digital Design and Synthesis," +%% Prentice Hall, 2003. ISBN: 0-13-044911-3 +%% +\lst@definelanguage{Verilog}% + {morekeywords={% reserved keywords + always,and,assign,automatic,begin,buf,bufif0,bufif1,case,casex,% + casez,cell,cmos,config,deassign,default,defparam,design,disable,% + edge,else,end,endcase,endconfig,endfunction,endgenerate,% + endmodule,endprimitive,endspecify,endtable,endtask,event,for,% + force,forever,fork,function,generate,genvar,highz0,highz1,if,% + ifnone,incdir,include,initial,inout,input,instance,integer,join,% + large,liblist,library,localparam,macromodule,medium,module,nand,% + negedge,nmos,nor,noshowcancelled,not,notif0,notif1,or,output,% + parameter,pmos,posedge,primitive,pull0,pull1,pulldown,pullup,% + pulsestyle_onevent,pulsestyle_ondetect,rcmos,real,realtime,reg,% + release,repeat,rnmos,rpmos,rtran,rtranif0,rtranif1,scalared,% + showcancelled,signed,small,specify,specparam,strong0,strong1,% + supply0,supply1,table,task,time,tran,tranif0,tranif1,tri,tri0,% + tri1,triand,trior,trireg,unsigned,use,vectored,wait,wand,weak0,% + weak1,while,wire,wor,xnor,xor},% + morekeywords=[2]{% system tasks and functions + $bitstoreal,$countdrivers,$display,$fclose,$fdisplay,$fmonitor,% + $fopen,$fstrobe,$fwrite,$finish,$getpattern,$history,$incsave,% + $input,$itor,$key,$list,$log,$monitor,$monitoroff,$monitoron,% + $nokey},% + morekeywords=[3]{% compiler directives + `accelerate,`autoexpand_vectornets,`celldefine,`default_nettype,% + `define,`else,`elsif,`endcelldefine,`endif,`endprotect,% + `endprotected,`expand_vectornets,`ifdef,`ifndef,`include,% + `no_accelerate,`noexpand_vectornets,`noremove_gatenames,% + `nounconnected_drive,`protect,`protected,`remove_gatenames,% + `remove_netnames,`resetall,`timescale,`unconnected_drive},% + alsoletter=\`,% + sensitive,% + morecomment=[s]{/*}{*/},% + morecomment=[l]//,% nonstandard + morestring=[b]"% + }[keywords,comments,strings]% +%% +%% AADL definition rolland jean-francois +%% rolland@irit.fr +%% +%% +%% +\lst@definelanguage{AADL}% + {morekeywords={% reserved keywords + aadlboolean,aadlinteger,aadlreal,aadlstring,% + access,all,and,annex,% + applies,behavior_specification,binding,bus,calls,% + classifier,complete,composite,computation,concurrent,% + connections,constant,count,data,% + delay,delta,device,else,elsif,end,enumeration,% + event,extends,false,features,% + flow,flows,for,fresh,history,group,if,implementation,% + in,inherit,initial,inverse,% + is,list,memory,mode,% + modes,none,not,of,on,% + or,out,package,parameter,% + path,port,private,process,% + processor,properties,property,provides,% + public,range,reference,refined,% + refines,requires,return,server,set,% + sink,source,state,states,subcomponents,subprogram,% + system,thread,timeout,to,transitions,true,% + type,units,urgent,value,variables,when% + },% + morecomment=[l]--,% + literate=% + {-[}{{\(- \hskip -0.2em[\)}}1% + {]->}{{\(]\hskip -0.4em\rightarrow\)}}1% + }[keywords,comments]% +%% +%% B +%% +\lst@definelanguage{AMN}% + {morekeywords={MACHINE,REFINEMENT,REFINES,SEES,INCLUDES,% + SETS,CONSTANTS,PROPERTIES,VARIABLES,INVARIANT,BEGIN,% + INITIALISATION,OPERATIONS,PRE,SELECT,THEN,END,IF,ELSE,WHILE,DO,VARIANT,% + CHOICE,OR,ANY,WHERE,VAR,IN},% + sensitive=true, + literate=% + {[]}{{\([\hskip -0.1em]\)}}1% + {>}{{\(>\)}}1% + {<}{{\(<\)}}1% + {->}{{\(\rightarrow\)}}1% + {<-}{{\(\leftarrow\)}}1% + {<--}{{\(\longleftarrow\)}}2% + {-->}{{\(\longrightarrow\)}}2% + {=>}{{\(\Rightarrow\)}}1% + {>=}{{\(\geq\)}}1% + {<=}{{\(\leq\)}}1% + {/\\}{{\(\cap\)}}1% + {\\/}{{\(\cup\)}}1% + {\{\}}{{\(\emptyset\)}}1% + {not}{{\(\lnot\)}}1% + {:}{{\(\in\)}}1% + {:(}{{:(}}1% + {::}{{\(:\!\in\)}}1% + {:=}{{:=}}1% + {<:}{{\(\subseteq\)}}1% + {<<:}{{\(\subset\)}}1% + {/=}{{\(\neq\)}}1% + {/:}{{\(\not\in\)}}1% + {\&}{{\(\land\)}}1,% + morecomment=[s]{/*}{*/},% + morestring=[d]",% + commentstyle={\textit},% + }[keywords,comments]% +%% +%% isabelle +%% +\lst@definelanguage{isabelle}% + {morekeywords={add,also,and,apply,assm,assume,assumes,axioms,begin,by,case,constdefs,done,end,else,if,fix,from,have,hints,imports,lemma,let,measure,moreover,next,note,obtain,proof,qed,recdef,rule,section,show,shows,subsection,then,theorem,theorems,theory,thesis,this,thus,types,ultimately,unfold,where,with},% + sensitive=true, + literate=% + {~}{\(\neg\)}1% + {==}{\(\triangleq\)}1% + {\{\}}{\(\emptyset\)}1% + {\\}{\(\land\)}1% + {\\}{\(\ldots\)}1% + {\\}{\(\exists\)}1% + {\\}{\(\forall\)}1% + {\\}{\(\in\)}1% + {\\}{\(\cap\)}1% + {\\}{\(\lambda\)}1% + {\\}{\(\Rightarrow\)}1% + {\\}{\(\not\in\)}1% + {\\}{\(\not=\)}1% + {\\}{\(\lor\)}1% + {\\}{\(\rightarrow\)}1% + {\\}{\(\subset\)}1% + {\\}{\(\times\)}1 + {\\}{\(\cup\)}1% + {\\}{\(\bigcup\)}1% + {\\}{\(\subseteq\)}1,% + morecomment=[s]{(*}{(*},% + commentstyle={\textit},% + }[keywords,comments]% +%% +%% +%% LTL +%% +\lst@definelanguage{LTL}% +{morekeywords={U,V},% +sensitive=true, +literate=% +{[]}{{\(\Box\)}}1% +{=>}{{\(\Rightarrow\)}}2% +{<>}{{\(\diamondsuit\)}}1% +{-}{{\(\neg\)}}1% +{()}{{\(\circ\)}}1% +morecomment=[l]{\\*},% +morestring=[d]",% +commentstyle={\textit},% +}[keywords,comments]% +%% +%% TLA +%% +\lst@definelanguage{TLA}% + {morekeywords={ASSUME, ELSE, LOCAL, UNION, + ASSUMPTION, ENABLED, MODULE, VARIABLE, + AXIOM, EXCEPT, OTHER, VARIABLES, + CASE, EXTENDS, SF_, WF_, + CHOOSE, IF, SUBSET, WITH, + CONSTANT, IN, THEN, + CONSTANTS , INSTANCE, THEOREM, + DOMAIN, LET, UNCHANGED},% + sensitive=true, + literate=% + {[]}{{\([\Box]\)}}1% + {>}{{\(>\)}}1% + {<}{{\(<\)}}1% + {->}{{\(\rightarrow\)}}1% + {|->}{{\(\mapsto\)}}1% + {<-}{{\(\leftarrow\)}}1% + {<--}{{\(\longleftarrow\)}}2% + {-->}{{\(\longrightarrow\)}}2% + {=>}{{\(\Rightarrow\)}}1% + {>=}{{\(\geq\)}}1% + {<=}{{\(\leq\)}}1% + {/\\}{{\(\land\)}}1% + {\\/}{{\(\lor\)}}1% + {\{\}}{{\(\emptyset\)}}1% + {not}{{\(\lnot\)}}1% + {\\E}{{\(\exists\)}}1% + {\\A}{{\(\forall\)}}1% + {\\in}{{\(\in\)}}1% + {::}{{\(:\!\in\)}}1% + {:=}{{:=}}1% + {<:}{{\(\subseteq\)}}1% + {<<:}{{\(\subset\)}}1% + {/=}{{\(\neq\)}}1% + {/:}{{\(\not\in\)}}1% + {==}{{\(\triangleq\)}}1% + {===}{{\(===\)}}1% + {\&}{{\(\land\)}}1,% + morecomment=[l]{\\*},% + morestring=[d]",% + commentstyle={\textit},% + }[keywords,comments]% +%% +%% +%% FIACRE +%% +\lst@definelanguage{FIACRE}% + {morekeywords={bool, nat, int, interval, enum, end, record, array, + of, queue, type, is, true, false, new, not, full, empty, + dequeue, first, and, or, enqueue, none, channel, in, out, read, + write, process, states, init, var, priority, from, null, any, + where, while, do, if, then, elsif, else, select, unless, on, to, inf, + component, shuffle, sync, par, port, property, leadsto, within, + after, absent, wait, always, function, begin, loop, + return, union},% + sensitive=true, + literate=% + {->}{{\(\rightarrow\)}}1% + {-o}{{\(\multimap\,\)}}1% + {=>}{{\(\Rightarrow\)}}1% + {>=}{{\(\geq\)}}1% + {<=}{{\(\leq\)}}1% + {||}{{\(\parallel\)}}1% + {:=}{{\(:=\)}}1,% +%% {[]}{{\(\Box\)~}}1,% + morecomment=[s]{/*}{*/},% + morestring=[d]",% + commentstyle={\textit},% + }[keywords,comments]% +%% +%% ALTARICA +%% +\lst@definelanguage{Altarica}% + {morekeywords={bool, nat, int, interval, enum, end, record, array, + of, queue, type, is, true, false, new, not, full, empty, + dequeue, first, and, or, enqueue, none, channel, in, out, read, + write, process, states, var, priority, from, null, any, case, + where, while, do, if, then, elsif, else, select, unless, on, to, inf, + component, sync, par, port, property, leadsto, within, + after, absent, always, extern, law, + trans, state, flow, domain, event, init, assert, node, edon, + case, else, reset}, + emphstyle=\color{black}\bfseries, + sensitive=true, + literate=% + {->}{{\(\rightarrow\)\,}}1% + {-o}{{\(\multimap\,\)}}1% + {=>}{{\(\Rightarrow\)}}1% + {>=}{{\(\geq\)}}1% + {<=}{{\(\leq\)}}1% + {|-}{{\raisebox{-1pt}{\(\vdash\)}}}1% + {::=}{{\(\ ::=\ \)}}1% + {<>}{{\(\Diamond\)}}1,% +%% {[]}{{\(\Box\)~}}1,% + morecomment=[s]{/*}{*/},% + morestring=[d]",% + commentstyle={\textit},% + }[keywords,comments]% +%% +%% BNF +%% +\lst@definelanguage{BNF}% + {morekeywords={bool, nat, int, type, is, union, end, null, if, + record, then, function, var, begin, return, process, states, + from, loop, on, select, component, par}, + emphstyle=\color{black}\bfseries, + sensitive=true, + literate=% + {::=}{{\(\ ::=\ \)}}1% + {[[}{{\(\llbracket\)}}1% + {]]}{{\(\rrbracket\)}}1% + {->}{{\(\rightarrow\,\)}}1% + {v-}{{\(\vdash\)}}1% + {|}{{\(\ \mid\ \)}}1,% +%% {[]}{{\(\Box\)~}}1,% + morecomment=[s]{/*}{*/},% + morestring=[d]",% + commentstyle={\textit},% + }[keywords,comments]% +%% +%% +%% +%% GenoM +%% +\lst@definelanguage{GenoM}% + {morekeywords={wcet, in, out, inout, port, codel, task, throw, int, + enum, ether, yield, activity, doc, validate, start, stop, ids, + interrupts, ms},% + sensitive=true, + morecomment=[s]{/*}{*/},% + morestring=[d]",% + commentstyle={\textit},% + }[keywords,comments]% +\endinput + + + + + + +%% End of file `lstlang3.sty'. + + + diff --git a/doc/Rapport post-doc/main.tex b/doc/Rapport post-doc/main.tex new file mode 100644 index 0000000..e65d711 --- /dev/null +++ b/doc/Rapport post-doc/main.tex @@ -0,0 +1,198 @@ + \documentclass[oribibl]{report} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\usepackage{natbib} +\usepackage{hyperref,verbatim} +\usepackage{listings,dirtytalk} +\usepackage{lstlang3} +\usepackage{amsmath,amsfonts,amssymb,stmaryrd} +\usepackage{graphicx, wrapfig} +\usepackage{latexsym} +\usepackage{units} +\usepackage{xspace}% +% \usepackage{wrapfig} + +\usepackage{xcolor} +\hypersetup{ + colorlinks, + linkcolor={red!50!black}, + citecolor={blue!50!black}, + urlcolor={blue!80!black} +} +\definecolor{bluekeywords}{rgb}{0.13,0.13,1} +\definecolor{greencomments}{rgb}{0,0.5,0} +\definecolor{redstrings}{rgb}{0.9,0,0} +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codepurple}{rgb}{0.58,0,0.82} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%% LISTINGS +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\font\bigttfont = cmtt12 scaled 1120 +\newcommand*{\ttfamilywithbold}{\fontfamily{lmtt}\selectfont} + +\def\code#1{{\ttfamilywithbold #1}}%{{\small\ttfamilywithbold #1}} +\def\vars#1{{\small\ttfamilywithbold #1}} + +\sbox0{\small\ttfamily A} +\edef\mybasewidth{\the\wd0 } +\lstset{inputencoding=latin1, + basicstyle=\footnotesize\ttfamilywithbold, + columns=fixed, + basewidth=\mybasewidth, + commentstyle=\commentaires, + keywordstyle=\bfseries, + % keywordstyle={[2]\itshape}, + keywordstyle=\color{bluekeywords}, + % basewidth=0.94ex, + showstringspaces=false, + % emptylines=1, + % aboveskip=-2pt,belowskip=-4pt, + mathescape=true, + texcl=true, + escapechar=@, + numberblanklines=false, + belowskip=-0.5em, + aboveskip=-0.5em, + commentstyle=\color{green},%{bluekeywords}, + belowcaptionskip=-1em +} + +% \usepackage{fancybox} +% \makeatletter +% \newenvironment{CenteredBox}{% +% \begin{Sbox}}{% Save the content in a box +% \end{Sbox}\centerline{\parbox{\wd\@Sbox}{\TheSbox}}}% And output it centered +% \makeatother + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\usepackage{tikz} +\usetikzlibrary{arrows,shapes,decorations,automata,backgrounds,petri,patterns,spy,decorations.markings,shadows} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\newtheorem{prop}{Safety Property}{\bfseries}{\rmfamily} +\newcommand{\PRE}[0]{\code{Pre}\xspace}% +\newcommand{\FUNC}[0]{\code{Function}\xspace}% +\newcommand{\ERR}[0]{\code{Err}\xspace}% +\newcommand{\LOSS}[0]{\code{Loss}\xspace} +\newcommand{\OK}[0]{\code{Ok}\xspace} +\newcommand{\MIN}[0]{\code{F3Mux}\xspace} +\newcommand{\ALARM}[0]{\code{Alarm}\xspace} +\newcommand{\SWITCH}[0]{\code{Switch}\xspace} +\newcommand{\FF}[2]{\code{F{#1}\_{#2}}\xspace} +\newcommand{\F}[1]{\code{F{#1}}\xspace} +\newcommand{\I}[1]{\code{I{#1}}\xspace} +\newcommand{\D}[1]{\code{D{#1}}\xspace} +\newtheorem{definition}{Definition} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\newcommand{\TODO}[1]{{\color{red}#1}} + +\setlength{\belowcaptionskip}{-1em} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +\makeatletter +%\renewcommand\bibsection% +%{\chapter*{\refname\@mkboth{\MakeUppercase{\refname}}{\MakeUppercase{\refname}}}} +\makeatother + +\begin{document} +%% +\title{Model-Checking Approach to Analyse\\ + Temporal Model Properties with AltaRica} +%% +\author{Alexandre Albore} +%%\institute{Institute of Research and Technology (IRT) Saint Exup\'ery, Toulouse, France \and +%%LAAS-CNRS, Universit\'e de Toulouse, CNRS, Toulouse, France \and +%%ONERA, 2 Avenue Edouard Belin, 31055 Toulouse, France +%% } +%% + + +%%\frontmatter + +\maketitle +\setcounter{footnote}{0} +%% +% \noindent\textbf{keywords:} Verification of Safety Requirements; System +% Architecture Specification; Realtime Model-Checking.\\ +%% +\begin{abstract} + The design of complex safety critical systems raises new technical + challenges for industrials. As systems become more complex---and + include more and more interacting functions---it becomes harder to + evaluate the safety implications of local failures and their + possible propagations through a whole system. That is all the more + true when we add time to the problem, that is when we consider the + impact of computation times and delays on the propagation of + failures. + + We describe an approach that extends models developed for Safety + Analysis with timing information and provide tools to reason on the + correctness of temporal safety conditions. Our approach is based on + an extension of the AltaRica language where we can associate timing + constraints with events and relies on a translation into a realtime + model-checking toolset. We illustrate our method with an example + that is representative of safety architectures found in critical + systems. This example shows that considering propagation delays + early during the validation of a system can help us uncover failure + modes that cannot be detected with the untimed models currently + used. +\end{abstract} + +\tableofcontents +% \section*{Acknowledgments}\label{sec:Acknowledgments} + +% Authors would like to thank YYYYY. + +% and could have a beneficial impact on the early validation of system +% behaviour +\chapter{Introduction} +\input{1-introduction} + +\chapter{State of the art} +\label{soa}\input{2-sota} + +\chapter{A Model-Checking Approach to Analyse Temporal Failure Propagation with AltaRica} +\label{altarica}\input{3-imbsa} + +\chapter{A Case Study: FDIR in a Satellite AOCS} +\label{aocs} +\input{4-aocs} + +\chapter{Conclusions} +\input{5-conclusions} + +\bibliographystyle{abbrv} + +\bibliography{paper,tina} + +\newpage +\appendix +\chapter*{Appendix A} +\setcounter{chapter}{1} + \input{app.tex} + +%\chapter*{Appendix} +%%\input{commandlines} +%% Good results and proving that a mathematical model underlying model representation allows to use properties and tools for automatic safety assessment. + +\end{document} + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: t +%%% End: diff --git a/doc/Rapport post-doc/main.toc b/doc/Rapport post-doc/main.toc new file mode 100644 index 0000000..63e105a --- /dev/null +++ b/doc/Rapport post-doc/main.toc @@ -0,0 +1,48 @@ +\contentsline {chapter}{\numberline {1}Introduction}{3}{chapter.1} +\contentsline {section}{\numberline {1.1}Toward an automated model-based approach to system validation}{3}{section.1.1} +\contentsline {subsection}{\numberline {1.1.1}Classical safety analysis techniques: FTA and FMEA}{4}{subsection.1.1.1} +\contentsline {subsection}{\numberline {1.1.2}Modern safety analysis techniques: MBSE and MBSA}{5}{subsection.1.1.2} +\contentsline {section}{\numberline {1.2}Automated Evaluation of Safety Temporal Conditions}{5}{section.1.2} +\contentsline {chapter}{\numberline {2}State of the art}{7}{chapter.2} +\contentsline {section}{\numberline {2.1}Modelling languages for Safety Analysis}{7}{section.2.1} +\contentsline {section}{\numberline {2.2}Safety Assessment on Temporal Properties}{8}{section.2.2} +\contentsline {section}{\numberline {2.3}Model-checking approach to safety assessment}{9}{section.2.3} +\contentsline {subsection}{\numberline {2.3.1}Tina model-checker}{10}{subsection.2.3.1} +\contentsline {chapter}{\numberline {3}A Model-Checking Approach to Analyse Temporal Failure Propagation with AltaRica}{12}{chapter.3} +\contentsline {section}{\numberline {3.1}Model-Based Safety Analysis with AltaRica}{13}{section.3.1} +\contentsline {subsection}{\numberline {3.1.1}AltaRica language and versions}{13}{subsection.3.1.1} +\contentsline {subsection}{\numberline {3.1.2}AltaRica modelling}{13}{subsection.3.1.2} +\contentsline {subsection}{\numberline {3.1.3}Time AltaRica: Adding Timing Constraints to Events}{15}{subsection.3.1.3} +\contentsline {section}{\numberline {3.2}A Definition of Fiacre Using Examples}{16}{section.3.2} +\contentsline {section}{\numberline {3.3}Example of a Failure Detection and Isolation System}{18}{section.3.3} +\contentsline {subsubsection}{Safety model of the architecture without FDI}{19}{section*.2} +\contentsline {subsubsection}{Safety model of the architecture with FDI}{21}{section*.3} +\contentsline {section}{\numberline {3.4}Compilation of AltaRica and Experimental evaluation}{22}{section.3.4} +\contentsline {subsection}{\numberline {3.4.1}Empirical evaluation}{24}{subsection.3.4.1} +\contentsline {chapter}{\numberline {4}A Case Study: FDIR in a Satellite AOCS}{26}{chapter.4} +\contentsline {section}{\numberline {4.1}An Expression of Industrial Needs and Requirements}{27}{section.4.1} +\contentsline {section}{\numberline {4.2}AOCS Case Study}{27}{section.4.2} +\contentsline {subsection}{\numberline {4.2.1}Architecture description}{28}{subsection.4.2.1} +\contentsline {subsection}{\numberline {4.2.2}AOCS mode automaton}{28}{subsection.4.2.2} +\contentsline {subsubsection}{OFF mode}{31}{section*.5} +\contentsline {subsubsection}{Acquisition \& Safe mode (ASM)}{31}{section*.6} +\contentsline {subsubsection}{Attitude Control Mode (ACM)}{31}{section*.7} +\contentsline {subsubsection}{Collision Avoidance Manœuvre (CAM)}{32}{section*.8} +\contentsline {subsubsection}{Orbit Control Mode (OCM)}{32}{section*.9} +\contentsline {subsubsection}{Formation Control Mode (FCM)}{33}{section*.10} +\contentsline {subsubsection}{Equipment}{33}{section*.11} +\contentsline {section}{\numberline {4.3}Case study modelling}{36}{section.4.3} +\contentsline {subsection}{\numberline {4.3.1}AltaRica modelling process}{37}{subsection.4.3.1} +\contentsline {subsection}{\numberline {4.3.2}Details of the model}{37}{subsection.4.3.2} +\contentsline {subsection}{\numberline {4.3.3}Empirical evaluation}{38}{subsection.4.3.3} +\contentsline {chapter}{\numberline {5}Conclusions}{41}{chapter.5} +\contentsline {section}{\numberline {5.1}Future Work}{42}{section.5.1} +\contentsline {section}{\numberline {A.1}Interpretation of AltaRica in Fiacre}{47}{section.A.1} +\contentsline {section}{\numberline {A.2}Method and translation}{51}{section.A.2} +\contentsline {subsection}{\numberline {A.2.1}Time Petri Nets}{51}{subsection.A.2.1} +\contentsline {subsubsection}{States in a TPN}{51}{section*.17} +\contentsline {subsection}{\numberline {A.2.2}From AltaRica to Tina}{52}{subsection.A.2.2} +\contentsline {subsection}{\numberline {A.2.3}Factored model of ETGTS}{52}{subsection.A.2.3} +\contentsline {subsubsection}{Semantics of a ETGTS}{53}{section*.18} +\contentsline {subsubsection}{Translation}{54}{section*.19} +\contentsline {section}{\numberline {A.3}Command line}{54}{section.A.3} diff --git a/doc/Rapport post-doc/paper.bib b/doc/Rapport post-doc/paper.bib new file mode 100644 index 0000000..0b8f83f --- /dev/null +++ b/doc/Rapport post-doc/paper.bib @@ -0,0 +1,427 @@ +@inproceedings{albore2017IMBSA, + title={A Model-Checking Approach to Analyse Temporal Failure Propagation with {A}lta{R}ica}, + author={Albore, Alexandre and Dal Zilio, Silvano and Infantes, Guillaume and Seguin, Christel and Virelizier, Pierre}, + booktitle={International Symposium on Model-Based Safety and Assessment -- LNCS}, + pages={147--162}, + year={2017}, + volume={10437}, + organization={Springer} +} + +@inproceedings{albore2018ERTS, + title={Timed Formal Model and Verification of Satellite {FDIR} in Early Design Phase}, + author={Albore, Alexandre and Dal Zilio, Silvano and de Roquemaurel, Marie and Seguin, Christel and Virelizier, Pierre}, + booktitle={9th European Congress on Embedded Real Time Software and Systems}, + OPTpages={147--162}, + year={2018}, + address={Toulouse, France} +} + + +@article{nusmv, + title={{NuSMV}: a new symbolic model checker}, + author={Cimatti, Alessandro and Clarke, Edmund and Giunchiglia, Fausto and Roveri, Marco}, + journal={International Journal on Software Tools for Technology Transfer}, + volume={2}, + number={4}, + pages={410--425}, + year={2000}, + publisher={Springer} +} + +@article{bozzano2010safety, + title={Safety, dependability and performance analysis of extended AADL models}, + author={Bozzano, Marco and Cimatti, Alessandro and Katoen, Joost-Pieter and Nguyen, Viet Yen and Noll, Thomas and Roveri, Marco}, + journal={The Computer Journal}, + volume={54}, + number={5}, + pages={754--775}, + year={2010}, + publisher={Oxford University Press} +} + +@inproceedings{PRISM, + title={PRISM 4.0: Verification of Probabilistic Real-time Systems}, + author={Kwiatkowska, Marta and Gethin, Norman and Parker, David}, + booktitle={International Conference on Computer Aided Verification (CAV’11) -- LNCS}, + pages={585-591}, + year={2011}, + volume={6806}, + organization={Springer} +} + +@inproceedings{brunel2017performing, + title={Performing Safety Analyses with AADL and AltaRica}, + author={Brunel, Julien and Feiler, Peter and Hugues, J{\'e}r{\^o}me and Lewis, Bruce and Prosvirnova, Tatiana and Seguin, Christel and Wrage, Lutz}, + booktitle={International Symposium on Model-Based Safety and Assessment -- LNCS}, + pages={67--81}, + year={2017}, + volume={10437}, + organization={Springer} +} + +@article{KNP04b, + author={M. Kwiatkowska and G. Norman and D. Parker}, + title={Probabilistic Symbolic Model Checking with {PRISM}: A Hybrid Approach}, + journal={International Journal on Software Tools for Technology Transfer (STTT)}, + year={2004}, + volume={6}, + number={2}, + pages={128--142} +} + +@Article{arn00, + author = {Arnold, A. and Griffault, A. and Point, G. and Rauzy, A.}, + title = {The {AltaRica} formalism for describing concurrent systems }, + journal = {Fundamenta Informatic{\ae}}, + year = {2000}, + volume = {40}, + number={2, 3}, + publisher={IOS Press}, + pages = {109-124} +} + +@book{Stamatis, + author = {Stamatis, D. H.}, + title = {Failure {M}ode and {E}ffect Analysis: {FMEA} from Theory to Execution}, + date = {2003}, + publisher = {ASQ Quality Press} +} + +@article{papadopoulos2011engineering, + title={Engineering failure analysis and design optimisation with {H}i{P}-{HOPS}}, + author={Papadopoulos, Yiannis and Walker, Martin and Parker, David and R{\"u}de, Erich and Hamann, Rainer and Uhlig, Andreas and Gr{\"a}tz, Uwe and Lien, Rune}, + journal={Engineering Failure Analysis}, + volume={18}, + number={2}, + pages={590--608}, + year={2011}, + publisher={Elsevier} +} + +@phdthesis{walker2009pandora, + title={Pandora: a logic for the qualitative analysis of temporal fault trees}, + author={Walker, Martin David}, + year={2009}, + school={The University of Hull} +} +@article{pagetti2004, + title={A timed extension for {A}lta{R}ica}, + author={Cassez, Franck and Pagetti, Claire and Roux, Olivier}, + journal={Fundamenta Informatic{\ae}}, + volume={62}, + number={3-4}, + pages={291--332}, + year={2004}, + publisher={IOS Press} +} + +@article{stamatelatos2002fault, + title={Fault tree handbook with aerospace applications}, + author={Stamatelatos, Michael and Vesely, William and Dugan, Joanne and Fragola, Joseph and Minarick, Joseph and Railsback, Jan}, + year={2002}, + publisher={{NASA}, Washington, DC} +} + +@book{FMEA, + author = {United States military procedure MIL-P-1629}, + title = {Procedure for performing a failure mode effect and criticality analysis}, + date = {1949} +} + + +@inproceedings{figaro, + author = {Bouissou, M}, + title = {Automated dependability analysis of complex systems with the KB3 workbench: the experience of EDF R\&D}, + booktitle = {Proceedings of CIEM}, + date = {2005}, + OPTeventtitle = {eventtitle}, + eventdate = {22–25 October 2005}, + venue = {Bucharest, Romania} +} + +@inproceedings{daws, + author = { Daws, C. and Yovine, S.}, + editor = {IEEE}, + title = {Reducing the Number of Clock Variables of Timed Automata}, + booktitle = {17th IEEE Real-Time Systems Symposium}, + date = {1996}, + venue = {Washington, DC} + +} + +@article{uppaal1997, + author = {K. G. Larsen and P. Pettersson and W. Yi}, + title = {UPPAAL in a nutshell}, + journaltitle = {International Journal on Software Tools for Technology Transfer (STTT)}, + date = {1997}, + volume = {1}, + number = {1}, + pages = {134-152} +} + +@inproceedings{uppaal2006, + title={{UPPAAL} 4.0}, + author={Behrmann, Gerd and David, Alexandre and Larsen, Kim Guldstrand and Hakansson, John and Petterson, Paul and Yi, Wang and Hendriks, Martijn}, + booktitle={Quantitative Evaluation of Systems, 2006 (QEST 2006)}, + pages={125--126}, + year={2006}, + organization={IEEE} +} + +@article{bernard2007experiments, + title={Experiments in model based safety analysis: {F}light controls}, + author={Bernard, Romain and Aubert, Jean-Jacques and Bieber, Pierre and Merlini, Christophe and Metge, Sylvain}, + journal={IFAC Proceedings Volumes}, + volume={40}, + number={6}, + pages={43--48}, + year={2007}, + publisher={Elsevier} +} +@inproceedings{bieber2002combination, + title={Combination of fault tree analysis and model checking for safety assessment of complex system}, + author={Bieber, Pierre and Castel, Charles and Seguin, Christel}, + booktitle={European Dependable Computing Conference}, + pages={19--31}, + year={2002}, + organization={Springer} +} +@InProceedings{poi99, + author = {Point, G. and Rauzy, A.}, + title = {{AltaRica} - Langage de mod{\'e}lisation par automates \`a contraintes}, + booktitle = {Actes du Congr\'es Mod\'elisation des Syst\`emes R\'eactifs}, + year = {1999}, + publisher = {Herm\`es ed.} +} + +@InProceedings{rauzy02, + author = {Rauzy, A.}, + title = {Mode automata and their compilation into fault trees}, + booktitle = {Reliability Engineering and +System Safety}, + year = {2002} +} + +@incollection{bieber2004safety, + title={Safety assessment with {A}ltarica}, + author={Bieber, Pierre and Bougnol, Christian and Castel, Charles and Kehren, Jean-Pierre Heckmann Christophe and Metge, Sylvain and Seguin, Christel}, + booktitle={Building the Information Society}, + pages={505--510}, + year={2004}, + publisher={Springer} +} + +@Article{rau08, + author = {Rauzy A.}, + title = {Guarded {T}ransition {S}ystems: a new States/Events Formalism for Reliability Studies}, + journal = {Journal of Risk and Reliability}, + year = {2008}, + volume = {222}, + number = {4} +} + +@article{prosvirnova2013altarica, + title={The {A}lta{R}ica 3.0 project for {M}odel-{B}ased {S}afety {A}ssessment}, + author={Prosvirnova, Tatiana and Batteux, Michel and Brameret, Pierre-Antoine and Cherfi, Abraham and Friedlhuber, Thomas and Roussel, Jean-Marc and Rauzy, Antoine}, + journal={IFAC Proceedings Volumes}, + volume={46}, + number={22}, + pages={127--132}, + year={2013}, + publisher={Elsevier} +} + +@inproceedings{thomas2013, + title={Model-Based {RAMS} \& {FDIR} Co-Engineering at {A}strium Satellites}, + author={Thomas, Dave and Blanquart, Jean-Paul}, + booktitle={Data System In Aerospace (DASIA 2013)}, + publisher ={ESA Special Publication}, + volume={720}, + pages={33}, + year={2013} +} + +@article{arnold1999altarica, + title={The {AltaRica} formalism for describing concurrent systems}, + author={Arnold, Andr{\'e} and Point, G{\'e}rald and Griffault, Alain and Rauzy, Antoine}, + journal={Fundamenta Informaticae}, + volume={40}, + number={2, 3}, + pages={109--124}, + year={1999}, + publisher={IOS Press} +} + +@inproceedings{bouissou05, + author = { Bouissou, M.}, + title = {Automated dependability analysis of complex systems with the KB3 workbench: the experience of EDF R\&D}, + booktitle = {International Conference on ENERGY and ENVIRONMENT (CIEM)}, + year = {2005} +} + +@inproceedings{bittner2014, + author = {Bittner, B. and Bozzano, M. and Cimatti, A. and De Ferluc, R. and Gario, M. and Guiotto, A. and Yushtein, Y.}, + title = {An Integrated Process for {FDIR} Design in Aerospace}, + booktitle = {International Symposium on Model Based Safety and Assessment (IMBSA)}, + year = {2014}, + venue = {Trento} +} + +@booklet{arc, + author = {Point, G. and Griffault, A. and Vincent, A.}, + title = {AltaRica Checker Handbook - A user-guide to ARC version 1}, + year = {2010}, + location = {Talence: LaBRI - CNRS UMR 5800 - Univ. de Bordeaux} +} + +@report{Griffault06, + author = {Griffault, A. and Point, G.}, + title = {On the partial translation of {L}ustre programs into the {A}lta{R}ica language and vice versa}, + type = {Research Report}, + institution = {LaBRI - CNRS UMR 5800}, + year = {2006}, + number = {1415-06}, + location = {Bordeaux} +} + + +@inproceedings{mec5, + author = {A. Griffault and A. Vincent}, + title = {The {MEC} 5 model-checker}, + booktitle = {International Conference on Computer Aided Verification}, + year = {2004} +} + +@inproceedings{rugina09, + author = {A.-E. Rugina and J.-P. Blanquart and R. Soumagne}, + title = {Validating {F}ailure {D}etection {I}solation and {R}ecovery {S}trategies using {T}imed {A}utomata}, + booktitle = {12th European Workshop on Dependable Computing (EWDC 2009)}, + year = {2009}, + venue = {Toulouse} +} + +@inproceedings{chaki2004, + title={State/event-based Software Model Checking}, + author={Chaki, Sagar and Clarke, Edmund M. and Ouaknine, Jo{\"e}l and Sharygina, Natasha and Sinha, Nishant}, + booktitle={International Conference on Integrated Formal Methods}, + pages={128--147}, + year={2004}, + organization={Springer} +} + +@inproceedings{cadp, + title={CADP a protocol validation and verification toolbox}, + author={Fernandez, Jean-Claude and Garavel, Hubert and Kerbrat, Alain and Mounier, Laurent and Mateescu, Radu and Sighireanu, Mihaela}, + booktitle={International Conference on Computer Aided Verification}, + pages={437--440}, + year={1996}, + organization={Springer} +} +@TechReport{Altarica2.3, + author = {Antoine B. Rauzy}, + title = {Alta{R}ica {D}ataflow Language Specification Version 2.3}, + institution = {Ecole Centrale de Paris}, + year = {2013}, + month = {June} +} + +@InProceedings{epoch, + author = {Teichteil-K{\"o}nigbuch, Florent and Infantes, Guillaume and Seguin, Christel }, + title = {{EPOCH} Probabilistic {M}odel-{C}hecking}, + booktitle = {{M}odel {B}ased {S}afety {A}ssessment workshop}, + year = {2011}, + address = {Toulouse, France} +} + +@inproceedings{bittner2016, + title={Automated synthesis of timed failure propagation graphs}, + author={Bittner, Benjamin and Bozzano, Marco and Cimatti, Alessandro}, + booktitle={Proc. Int. Joint Conf. of Artificial Intelligence (IJCAI-16)}, + pages={972--978}, + year={2016} +} + +@article{bozzano2012, + title={Symbolic {M}odel {C}hecking and safety assessment of {AltaRica} models}, + author={Bozzano, Marco and Cimatti, Alessandro and Lisagor, Oleg and Mattarei, Cristian and Mover, Sergio and Roveri, Marco and Tonetta, Stefano}, + journal={Electronic Communications of the EASST}, + volume={46}, + year={2012} +} + +@article{berthomieu1991TPN, + title={Modeling and verification of time dependent systems using time {P}etri nets}, + author={Berthomieu, Bernard and Diaz, Michel}, + journal={IEEE transactions on software engineering}, + volume={17}, + number={3}, + pages={259--273}, + year={1991}, + publisher={IEEE} +} + +@inproceedings{Zalila, + author = {Zalila, F. and Jenn, É. and Pantel, M. }, + title = {Model Execution and Debugging - A Process to Leverage Existing Tools}, + booktitle = { 5th International Conference on Model-Driven Engineering and Software Development}, + year = {2017} +} + + +@incollection{synoptic, + author = {A. Cortier and L. Besnard and J. P. Bodeveix and J. Buisson and F. Dagnat and M. Filali and G. Garcia and J. Ouy and M. Pantel and A.-E. Rugina and M. Strecker and J.P. Talpin}, + title = {Synoptic: A Domain-Specific Modeling Language for Space On-board Application Software}, + booktitle = {Synthesis of Embedded Software}, + date = {2010} +} + +@manual{sutre09, + author = { Sutre , G. and Herbreteau, F. and Fleury, F.}, + title = {Traduction de Synoptic en {AltaRica}}, + year = {2009}, + organization = {LaBRI} +} + +@article{merlin1976, + title={Recoverability of communication protocols--implications of a theoretical study}, + author={Merlin, Philip and Farber, David}, + journal={IEEE transactions on Communications}, + volume={24}, + number={9}, + pages={1036--1043}, + year={1976}, + publisher={IEEE} +} + +@article{yao, + title={A {P}etri net model for temporal knowledge representation and reasoning}, + author={Yao, Yulin}, + journal={IEEE Transactions on Systems, Man, and Cybernetics}, + volume={24}, + number={9}, + pages={1374--1382}, + year={1994}, + publisher={IEEE} +} + + +@book{ECSS‐E‐ST‐70‐11C, + title = {Space segment operability}, + month = {31 July }, + year={2008}, + number = {ECSS-E-ST-70-11C} +} + + +@book{ECSS-E-ST-60-30C, + title = {Satellite attitude and orbit control system ({AOCS}) requirements}, + month ={30 August }, + year={2013}, + number = {ECSS-E-ST-60-30C} +} + +@book{ASRA, +title={Avionics {S}ystem {R}eference {A}rchitecture ({ASRA})}, +publisher={ESA contract {4 000 102 927}} +} \ No newline at end of file diff --git a/doc/Rapport post-doc/readme.txt b/doc/Rapport post-doc/readme.txt new file mode 100644 index 0000000..47161bd --- /dev/null +++ b/doc/Rapport post-doc/readme.txt @@ -0,0 +1,30 @@ +Dear LLNCS user, + +The files in this directory belong to the LaTeX2e package for +Lecture Notes in Computer Science (LNCS) of Springer-Verlag. + +It consists of the following files: + + readme.txt this file + + history.txt the version history of the package + + llncs.cls the LaTeX2e document class + + llncs.dem the sample input file + + llncs.doc the documentation of the class (LaTeX source) + llncsdoc.pdf the documentation of the class (PDF version) + llncsdoc.sty the modification of the class for the documentation + llncs.ind an external (faked) author index file + subjidx.ind subject index demo from the Springer book package + llncs.dvi the resultig DVI file (remember to use binary transfer!) + + sprmindx.sty supplementary style file for MakeIndex + (usage: makeindex -s sprmindx.sty ) + + splncs03.bst current LNCS BibTeX style with alphabetic sorting + + aliascnt.sty part of the Oberdiek bundle; allows more control over + the counters associated to any numbered item + remreset.sty by David Carlisle diff --git a/doc/Rapport post-doc/remreset.sty b/doc/Rapport post-doc/remreset.sty new file mode 100644 index 0000000..b53de58 --- /dev/null +++ b/doc/Rapport post-doc/remreset.sty @@ -0,0 +1,39 @@ + +% remreset package +%%%%%%%%%%%%%%%%%% + +% Copyright 1997 David carlisle +% This file may be distributed under the terms of the LPPL. +% See 00readme.txt for details. + +% 1997/09/28 David Carlisle + +% LaTeX includes a command \@addtoreset that is used to declare that +% a counter should be reset every time a second counter is incremented. + +% For example the book class has a line +% \@addtoreset{footnote}{chapter} +% So that the footnote counter is reset each chapter. + +% If you wish to bas a new class on book, but without this counter +% being reset, then standard LaTeX gives no simple mechanism to do +% this. + +% This package defines |\@removefromreset| which just undoes the effect +% of \@addtorest. So for example a class file may be defined by + +% \LoadClass{book} +% \@removefromreset{footnote}{chapter} + + +\def\@removefromreset#1#2{{% + \expandafter\let\csname c@#1\endcsname\@removefromreset + \def\@elt##1{% + \expandafter\ifx\csname c@##1\endcsname\@removefromreset + \else + \noexpand\@elt{##1}% + \fi}% + \expandafter\xdef\csname cl@#2\endcsname{% + \csname cl@#2\endcsname}}} + + diff --git a/doc/Rapport post-doc/splncs03.bst b/doc/Rapport post-doc/splncs03.bst new file mode 100644 index 0000000..3279169 --- /dev/null +++ b/doc/Rapport post-doc/splncs03.bst @@ -0,0 +1,1519 @@ +%% BibTeX bibliography style `splncs03' +%% +%% BibTeX bibliography style for use with numbered references in +%% Springer Verlag's "Lecture Notes in Computer Science" series. +%% (See Springer's documentation for llncs.cls for +%% more details of the suggested reference format.) Note that this +%% file will not work for author-year style citations. +%% +%% Use \documentclass{llncs} and \bibliographystyle{splncs03}, and cite +%% a reference with (e.g.) \cite{smith77} to get a "[1]" in the text. +%% +%% This file comes to you courtesy of Maurizio "Titto" Patrignani of +%% Dipartimento di Informatica e Automazione Universita' Roma Tre +%% +%% ================================================================================================ +%% This was file `titto-lncs-02.bst' produced on Wed Apr 1, 2009 +%% Edited by hand by titto based on `titto-lncs-01.bst' (see below) +%% +%% CHANGES (with respect to titto-lncs-01.bst): +%% - Removed the call to \urlprefix (thus no "URL" string is added to the output) +%% ================================================================================================ +%% This was file `titto-lncs-01.bst' produced on Fri Aug 22, 2008 +%% Edited by hand by titto based on `titto.bst' (see below) +%% +%% CHANGES (with respect to titto.bst): +%% - Removed the "capitalize" command for editors string "(eds.)" and "(ed.)" +%% - Introduced the functions titto.bbl.pages and titto.bbl.page for journal pages (without "pp.") +%% - Added a new.sentence command to separate with a dot booktitle and series in the inproceedings +%% - Commented all new.block commands before urls and notes (to separate them with a comma) +%% - Introduced the functions titto.bbl.volume for handling journal volumes (without "vol." label) +%% - Used for editors the same name conventions used for authors (see function format.in.ed.booktitle) +%% - Removed a \newblock to avoid long spaces between title and "In: ..." +%% - Added function titto.space.prefix to add a space instead of "~" after the (removed) "vol." label +%% ================================================================================================ +%% This was file `titto.bst', +%% generated with the docstrip utility. +%% +%% The original source files were: +%% +%% merlin.mbs (with options: `vonx,nm-rvvc,yr-par,jttl-rm,volp-com,jwdpg,jwdvol,numser,ser-vol,jnm-x,btit-rm,bt-rm,edparxc,bkedcap,au-col,in-col,fin-bare,pp,ed,abr,mth-bare,xedn,jabr,and-com,and-com-ed,xand,url,url-blk,em-x,nfss,') +%% ---------------------------------------- +%% *** Tentative .bst file for Springer LNCS *** +%% +%% Copyright 1994-2007 Patrick W Daly + % =============================================================== + % IMPORTANT NOTICE: + % This bibliographic style (bst) file has been generated from one or + % more master bibliographic style (mbs) files, listed above. + % + % This generated file can be redistributed and/or modified under the terms + % of the LaTeX Project Public License Distributed from CTAN + % archives in directory macros/latex/base/lppl.txt; either + % version 1 of the License, or any later version. + % =============================================================== + % Name and version information of the main mbs file: + % \ProvidesFile{merlin.mbs}[2007/04/24 4.20 (PWD, AO, DPC)] + % For use with BibTeX version 0.99a or later + %------------------------------------------------------------------- + % This bibliography style file is intended for texts in ENGLISH + % This is a numerical citation style, and as such is standard LaTeX. + % It requires no extra package to interface to the main text. + % The form of the \bibitem entries is + % \bibitem{key}... + % Usage of \cite is as follows: + % \cite{key} ==>> [#] + % \cite[chap. 2]{key} ==>> [#, chap. 2] + % where # is a number determined by the ordering in the reference list. + % The order in the reference list is alphabetical by authors. + %--------------------------------------------------------------------- + +ENTRY + { address + author + booktitle + chapter + edition + editor + eid + howpublished + institution + journal + key + month + note + number + organization + pages + publisher + school + series + title + type + url + volume + year + } + {} + { label } +INTEGERS { output.state before.all mid.sentence after.sentence after.block } +FUNCTION {init.state.consts} +{ #0 'before.all := + #1 'mid.sentence := + #2 'after.sentence := + #3 'after.block := +} +STRINGS { s t} +FUNCTION {output.nonnull} +{ 's := + output.state mid.sentence = + { ", " * write$ } + { output.state after.block = + { add.period$ write$ +% newline$ +% "\newblock " write$ % removed for titto-lncs-01 + " " write$ % to avoid long spaces between title and "In: ..." + } + { output.state before.all = + 'write$ + { add.period$ " " * write$ } + if$ + } + if$ + mid.sentence 'output.state := + } + if$ + s +} +FUNCTION {output} +{ duplicate$ empty$ + 'pop$ + 'output.nonnull + if$ +} +FUNCTION {output.check} +{ 't := + duplicate$ empty$ + { pop$ "empty " t * " in " * cite$ * warning$ } + 'output.nonnull + if$ +} +FUNCTION {fin.entry} +{ duplicate$ empty$ + 'pop$ + 'write$ + if$ + newline$ +} + +FUNCTION {new.block} +{ output.state before.all = + 'skip$ + { after.block 'output.state := } + if$ +} +FUNCTION {new.sentence} +{ output.state after.block = + 'skip$ + { output.state before.all = + 'skip$ + { after.sentence 'output.state := } + if$ + } + if$ +} +FUNCTION {add.blank} +{ " " * before.all 'output.state := +} + + +FUNCTION {add.colon} +{ duplicate$ empty$ + 'skip$ + { ":" * add.blank } + if$ +} + +FUNCTION {date.block} +{ + new.block +} + +FUNCTION {not} +{ { #0 } + { #1 } + if$ +} +FUNCTION {and} +{ 'skip$ + { pop$ #0 } + if$ +} +FUNCTION {or} +{ { pop$ #1 } + 'skip$ + if$ +} +STRINGS {z} +FUNCTION {remove.dots} +{ 'z := + "" + { z empty$ not } + { z #1 #1 substring$ + z #2 global.max$ substring$ 'z := + duplicate$ "." = 'pop$ + { * } + if$ + } + while$ +} +FUNCTION {new.block.checka} +{ empty$ + 'skip$ + 'new.block + if$ +} +FUNCTION {new.block.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.block + if$ +} +FUNCTION {new.sentence.checka} +{ empty$ + 'skip$ + 'new.sentence + if$ +} +FUNCTION {new.sentence.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.sentence + if$ +} +FUNCTION {field.or.null} +{ duplicate$ empty$ + { pop$ "" } + 'skip$ + if$ +} +FUNCTION {emphasize} +{ skip$ } +FUNCTION {tie.or.space.prefix} +{ duplicate$ text.length$ #3 < + { "~" } + { " " } + if$ + swap$ +} +FUNCTION {titto.space.prefix} % always introduce a space +{ duplicate$ text.length$ #3 < + { " " } + { " " } + if$ + swap$ +} + + +FUNCTION {capitalize} +{ "u" change.case$ "t" change.case$ } + +FUNCTION {space.word} +{ " " swap$ * " " * } + % Here are the language-specific definitions for explicit words. + % Each function has a name bbl.xxx where xxx is the English word. + % The language selected here is ENGLISH +FUNCTION {bbl.and} +{ "and"} + +FUNCTION {bbl.etal} +{ "et~al." } + +FUNCTION {bbl.editors} +{ "eds." } + +FUNCTION {bbl.editor} +{ "ed." } + +FUNCTION {bbl.edby} +{ "edited by" } + +FUNCTION {bbl.edition} +{ "edn." } + +FUNCTION {bbl.volume} +{ "vol." } + +FUNCTION {titto.bbl.volume} % for handling journals +{ "" } + +FUNCTION {bbl.of} +{ "of" } + +FUNCTION {bbl.number} +{ "no." } + +FUNCTION {bbl.nr} +{ "no." } + +FUNCTION {bbl.in} +{ "in" } + +FUNCTION {bbl.pages} +{ "pp." } + +FUNCTION {bbl.page} +{ "p." } + +FUNCTION {titto.bbl.pages} % for journals +{ "" } + +FUNCTION {titto.bbl.page} % for journals +{ "" } + +FUNCTION {bbl.chapter} +{ "chap." } + +FUNCTION {bbl.techrep} +{ "Tech. Rep." } + +FUNCTION {bbl.mthesis} +{ "Master's thesis" } + +FUNCTION {bbl.phdthesis} +{ "Ph.D. thesis" } + +MACRO {jan} {"Jan."} + +MACRO {feb} {"Feb."} + +MACRO {mar} {"Mar."} + +MACRO {apr} {"Apr."} + +MACRO {may} {"May"} + +MACRO {jun} {"Jun."} + +MACRO {jul} {"Jul."} + +MACRO {aug} {"Aug."} + +MACRO {sep} {"Sep."} + +MACRO {oct} {"Oct."} + +MACRO {nov} {"Nov."} + +MACRO {dec} {"Dec."} + +MACRO {acmcs} {"ACM Comput. Surv."} + +MACRO {acta} {"Acta Inf."} + +MACRO {cacm} {"Commun. ACM"} + +MACRO {ibmjrd} {"IBM J. Res. Dev."} + +MACRO {ibmsj} {"IBM Syst.~J."} + +MACRO {ieeese} {"IEEE Trans. Software Eng."} + +MACRO {ieeetc} {"IEEE Trans. Comput."} + +MACRO {ieeetcad} + {"IEEE Trans. Comput. Aid. Des."} + +MACRO {ipl} {"Inf. Process. Lett."} + +MACRO {jacm} {"J.~ACM"} + +MACRO {jcss} {"J.~Comput. Syst. Sci."} + +MACRO {scp} {"Sci. Comput. Program."} + +MACRO {sicomp} {"SIAM J. Comput."} + +MACRO {tocs} {"ACM Trans. Comput. Syst."} + +MACRO {tods} {"ACM Trans. Database Syst."} + +MACRO {tog} {"ACM Trans. Graphic."} + +MACRO {toms} {"ACM Trans. Math. Software"} + +MACRO {toois} {"ACM Trans. Office Inf. Syst."} + +MACRO {toplas} {"ACM Trans. Progr. Lang. Syst."} + +MACRO {tcs} {"Theor. Comput. Sci."} + +FUNCTION {bibinfo.check} +{ swap$ + duplicate$ missing$ + { + pop$ pop$ + "" + } + { duplicate$ empty$ + { + swap$ pop$ + } + { swap$ + pop$ + } + if$ + } + if$ +} +FUNCTION {bibinfo.warn} +{ swap$ + duplicate$ missing$ + { + swap$ "missing " swap$ * " in " * cite$ * warning$ pop$ + "" + } + { duplicate$ empty$ + { + swap$ "empty " swap$ * " in " * cite$ * warning$ + } + { swap$ + pop$ + } + if$ + } + if$ +} +FUNCTION {format.url} +{ url empty$ + { "" } +% { "\urlprefix\url{" url * "}" * } + { "\url{" url * "}" * } % changed in titto-lncs-02.bst + if$ +} + +INTEGERS { nameptr namesleft numnames } + + +STRINGS { bibinfo} + +FUNCTION {format.names} +{ 'bibinfo := + duplicate$ empty$ 'skip$ { + 's := + "" 't := + #1 'nameptr := + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr + "{vv~}{ll}{, jj}{, f{.}.}" + format.name$ + bibinfo bibinfo.check + 't := + nameptr #1 > + { + namesleft #1 > + { ", " * t * } + { + s nameptr "{ll}" format.name$ duplicate$ "others" = + { 't := } + { pop$ } + if$ + "," * + t "others" = + { + " " * bbl.etal * + } + { " " * t * } + if$ + } + if$ + } + 't + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ + } if$ +} +FUNCTION {format.names.ed} +{ + 'bibinfo := + duplicate$ empty$ 'skip$ { + 's := + "" 't := + #1 'nameptr := + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr + "{f{.}.~}{vv~}{ll}{ jj}" + format.name$ + bibinfo bibinfo.check + 't := + nameptr #1 > + { + namesleft #1 > + { ", " * t * } + { + s nameptr "{ll}" format.name$ duplicate$ "others" = + { 't := } + { pop$ } + if$ + "," * + t "others" = + { + + " " * bbl.etal * + } + { " " * t * } + if$ + } + if$ + } + 't + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ + } if$ +} +FUNCTION {format.authors} +{ author "author" format.names +} +FUNCTION {get.bbl.editor} +{ editor num.names$ #1 > 'bbl.editors 'bbl.editor if$ } + +FUNCTION {format.editors} +{ editor "editor" format.names duplicate$ empty$ 'skip$ + { + " " * + get.bbl.editor +% capitalize + "(" swap$ * ")" * + * + } + if$ +} +FUNCTION {format.note} +{ + note empty$ + { "" } + { note #1 #1 substring$ + duplicate$ "{" = + 'skip$ + { output.state mid.sentence = + { "l" } + { "u" } + if$ + change.case$ + } + if$ + note #2 global.max$ substring$ * "note" bibinfo.check + } + if$ +} + +FUNCTION {format.title} +{ title + duplicate$ empty$ 'skip$ + { "t" change.case$ } + if$ + "title" bibinfo.check +} +FUNCTION {output.bibitem} +{ newline$ + "\bibitem{" write$ + cite$ write$ + "}" write$ + newline$ + "" + before.all 'output.state := +} + +FUNCTION {n.dashify} +{ + 't := + "" + { t empty$ not } + { t #1 #1 substring$ "-" = + { t #1 #2 substring$ "--" = not + { "--" * + t #2 global.max$ substring$ 't := + } + { { t #1 #1 substring$ "-" = } + { "-" * + t #2 global.max$ substring$ 't := + } + while$ + } + if$ + } + { t #1 #1 substring$ * + t #2 global.max$ substring$ 't := + } + if$ + } + while$ +} + +FUNCTION {word.in} +{ bbl.in capitalize + ":" * + " " * } + +FUNCTION {format.date} +{ + month "month" bibinfo.check + duplicate$ empty$ + year "year" bibinfo.check duplicate$ empty$ + { swap$ 'skip$ + { "there's a month but no year in " cite$ * warning$ } + if$ + * + } + { swap$ 'skip$ + { + swap$ + " " * swap$ + } + if$ + * + remove.dots + } + if$ + duplicate$ empty$ + 'skip$ + { + before.all 'output.state := + " (" swap$ * ")" * + } + if$ +} +FUNCTION {format.btitle} +{ title "title" bibinfo.check + duplicate$ empty$ 'skip$ + { + } + if$ +} +FUNCTION {either.or.check} +{ empty$ + 'pop$ + { "can't use both " swap$ * " fields in " * cite$ * warning$ } + if$ +} +FUNCTION {format.bvolume} +{ volume empty$ + { "" } + { bbl.volume volume tie.or.space.prefix + "volume" bibinfo.check * * + series "series" bibinfo.check + duplicate$ empty$ 'pop$ + { emphasize ", " * swap$ * } + if$ + "volume and number" number either.or.check + } + if$ +} +FUNCTION {format.number.series} +{ volume empty$ + { number empty$ + { series field.or.null } + { output.state mid.sentence = + { bbl.number } + { bbl.number capitalize } + if$ + number tie.or.space.prefix "number" bibinfo.check * * + series empty$ + { "there's a number but no series in " cite$ * warning$ } + { bbl.in space.word * + series "series" bibinfo.check * + } + if$ + } + if$ + } + { "" } + if$ +} + +FUNCTION {format.edition} +{ edition duplicate$ empty$ 'skip$ + { + output.state mid.sentence = + { "l" } + { "t" } + if$ change.case$ + "edition" bibinfo.check + " " * bbl.edition * + } + if$ +} +INTEGERS { multiresult } +FUNCTION {multi.page.check} +{ 't := + #0 'multiresult := + { multiresult not + t empty$ not + and + } + { t #1 #1 substring$ + duplicate$ "-" = + swap$ duplicate$ "," = + swap$ "+" = + or or + { #1 'multiresult := } + { t #2 global.max$ substring$ 't := } + if$ + } + while$ + multiresult +} +FUNCTION {format.pages} +{ pages duplicate$ empty$ 'skip$ + { duplicate$ multi.page.check + { + bbl.pages swap$ + n.dashify + } + { + bbl.page swap$ + } + if$ + tie.or.space.prefix + "pages" bibinfo.check + * * + } + if$ +} +FUNCTION {format.journal.pages} +{ pages duplicate$ empty$ 'pop$ + { swap$ duplicate$ empty$ + { pop$ pop$ format.pages } + { + ", " * + swap$ + n.dashify + pages multi.page.check + 'titto.bbl.pages + 'titto.bbl.page + if$ + swap$ tie.or.space.prefix + "pages" bibinfo.check + * * + * + } + if$ + } + if$ +} +FUNCTION {format.journal.eid} +{ eid "eid" bibinfo.check + duplicate$ empty$ 'pop$ + { swap$ duplicate$ empty$ 'skip$ + { + ", " * + } + if$ + swap$ * + } + if$ +} +FUNCTION {format.vol.num.pages} % this function is used only for journal entries +{ volume field.or.null + duplicate$ empty$ 'skip$ + { +% bbl.volume swap$ tie.or.space.prefix + titto.bbl.volume swap$ titto.space.prefix +% rationale for the change above: for journals you don't want "vol." label +% hence it does not make sense to attach the journal number to the label when +% it is short + "volume" bibinfo.check + * * + } + if$ + number "number" bibinfo.check duplicate$ empty$ 'skip$ + { + swap$ duplicate$ empty$ + { "there's a number but no volume in " cite$ * warning$ } + 'skip$ + if$ + swap$ + "(" swap$ * ")" * + } + if$ * + eid empty$ + { format.journal.pages } + { format.journal.eid } + if$ +} + +FUNCTION {format.chapter.pages} +{ chapter empty$ + 'format.pages + { type empty$ + { bbl.chapter } + { type "l" change.case$ + "type" bibinfo.check + } + if$ + chapter tie.or.space.prefix + "chapter" bibinfo.check + * * + pages empty$ + 'skip$ + { ", " * format.pages * } + if$ + } + if$ +} + +FUNCTION {format.booktitle} +{ + booktitle "booktitle" bibinfo.check +} +FUNCTION {format.in.ed.booktitle} +{ format.booktitle duplicate$ empty$ 'skip$ + { +% editor "editor" format.names.ed duplicate$ empty$ 'pop$ % changed by titto + editor "editor" format.names duplicate$ empty$ 'pop$ + { + " " * + get.bbl.editor +% capitalize + "(" swap$ * ") " * + * swap$ + * } + if$ + word.in swap$ * + } + if$ +} +FUNCTION {empty.misc.check} +{ author empty$ title empty$ howpublished empty$ + month empty$ year empty$ note empty$ + and and and and and + key empty$ not and + { "all relevant fields are empty in " cite$ * warning$ } + 'skip$ + if$ +} +FUNCTION {format.thesis.type} +{ type duplicate$ empty$ + 'pop$ + { swap$ pop$ + "t" change.case$ "type" bibinfo.check + } + if$ +} +FUNCTION {format.tr.number} +{ number "number" bibinfo.check + type duplicate$ empty$ + { pop$ bbl.techrep } + 'skip$ + if$ + "type" bibinfo.check + swap$ duplicate$ empty$ + { pop$ "t" change.case$ } + { tie.or.space.prefix * * } + if$ +} +FUNCTION {format.article.crossref} +{ + key duplicate$ empty$ + { pop$ + journal duplicate$ empty$ + { "need key or journal for " cite$ * " to crossref " * crossref * warning$ } + { "journal" bibinfo.check emphasize word.in swap$ * } + if$ + } + { word.in swap$ * " " *} + if$ + " \cite{" * crossref * "}" * +} +FUNCTION {format.crossref.editor} +{ editor #1 "{vv~}{ll}" format.name$ + "editor" bibinfo.check + editor num.names$ duplicate$ + #2 > + { pop$ + "editor" bibinfo.check + " " * bbl.etal + * + } + { #2 < + 'skip$ + { editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" = + { + "editor" bibinfo.check + " " * bbl.etal + * + } + { + bbl.and space.word + * editor #2 "{vv~}{ll}" format.name$ + "editor" bibinfo.check + * + } + if$ + } + if$ + } + if$ +} +FUNCTION {format.book.crossref} +{ volume duplicate$ empty$ + { "empty volume in " cite$ * "'s crossref of " * crossref * warning$ + pop$ word.in + } + { bbl.volume + capitalize + swap$ tie.or.space.prefix "volume" bibinfo.check * * bbl.of space.word * + } + if$ + editor empty$ + editor field.or.null author field.or.null = + or + { key empty$ + { series empty$ + { "need editor, key, or series for " cite$ * " to crossref " * + crossref * warning$ + "" * + } + { series emphasize * } + if$ + } + { key * } + if$ + } + { format.crossref.editor * } + if$ + " \cite{" * crossref * "}" * +} +FUNCTION {format.incoll.inproc.crossref} +{ + editor empty$ + editor field.or.null author field.or.null = + or + { key empty$ + { format.booktitle duplicate$ empty$ + { "need editor, key, or booktitle for " cite$ * " to crossref " * + crossref * warning$ + } + { word.in swap$ * } + if$ + } + { word.in key * " " *} + if$ + } + { word.in format.crossref.editor * " " *} + if$ + " \cite{" * crossref * "}" * +} +FUNCTION {format.org.or.pub} +{ 't := + "" + address empty$ t empty$ and + 'skip$ + { + t empty$ + { address "address" bibinfo.check * + } + { t * + address empty$ + 'skip$ + { ", " * address "address" bibinfo.check * } + if$ + } + if$ + } + if$ +} +FUNCTION {format.publisher.address} +{ publisher "publisher" bibinfo.warn format.org.or.pub +} + +FUNCTION {format.organization.address} +{ organization "organization" bibinfo.check format.org.or.pub +} + +FUNCTION {article} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.title "title" output.check + new.block + crossref missing$ + { + journal + "journal" bibinfo.check + "journal" output.check + add.blank + format.vol.num.pages output + format.date "year" output.check + } + { format.article.crossref output.nonnull + format.pages output + } + if$ +% new.block + format.url output +% new.block + format.note output + fin.entry +} +FUNCTION {book} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check + add.colon + } + { format.authors output.nonnull + add.colon + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + new.block + new.sentence + format.number.series output + format.publisher.address output + } + { + new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + format.date "year" output.check +% new.block + format.url output +% new.block + format.note output + fin.entry +} +FUNCTION {booklet} +{ output.bibitem + format.authors output + add.colon + new.block + format.title "title" output.check + new.block + howpublished "howpublished" bibinfo.check output + address "address" bibinfo.check output + format.date output +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {inbook} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check + add.colon + } + { format.authors output.nonnull + add.colon + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + new.block + format.btitle "title" output.check + crossref missing$ + { + format.bvolume output + format.chapter.pages "chapter and pages" output.check + new.block + new.sentence + format.number.series output + format.publisher.address output + } + { + format.chapter.pages "chapter and pages" output.check + new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + format.date "year" output.check +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {incollection} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.chapter.pages output + new.sentence + format.number.series output + format.publisher.address output + format.edition output + format.date "year" output.check + } + { format.incoll.inproc.crossref output.nonnull + format.chapter.pages output + } + if$ +% new.block + format.url output +% new.block + format.note output + fin.entry +} +FUNCTION {inproceedings} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + new.sentence % added by titto + format.bvolume output + format.pages output + new.sentence + format.number.series output + publisher empty$ + { format.organization.address output } + { organization "organization" bibinfo.check output + format.publisher.address output + } + if$ + format.date "year" output.check + } + { format.incoll.inproc.crossref output.nonnull + format.pages output + } + if$ +% new.block + format.url output +% new.block + format.note output + fin.entry +} +FUNCTION {conference} { inproceedings } +FUNCTION {manual} +{ output.bibitem + author empty$ + { organization "organization" bibinfo.check + duplicate$ empty$ 'pop$ + { output + address "address" bibinfo.check output + } + if$ + } + { format.authors output.nonnull } + if$ + add.colon + new.block + format.btitle "title" output.check + author empty$ + { organization empty$ + { + address new.block.checka + address "address" bibinfo.check output + } + 'skip$ + if$ + } + { + organization address new.block.checkb + organization "organization" bibinfo.check output + address "address" bibinfo.check output + } + if$ + format.edition output + format.date output +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {mastersthesis} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.btitle + "title" output.check + new.block + bbl.mthesis format.thesis.type output.nonnull + school "school" bibinfo.warn output + address "address" bibinfo.check output + format.date "year" output.check +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {misc} +{ output.bibitem + format.authors output + add.colon + title howpublished new.block.checkb + format.title output + howpublished new.block.checka + howpublished "howpublished" bibinfo.check output + format.date output +% new.block + format.url output +% new.block + format.note output + fin.entry + empty.misc.check +} +FUNCTION {phdthesis} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.btitle + "title" output.check + new.block + bbl.phdthesis format.thesis.type output.nonnull + school "school" bibinfo.warn output + address "address" bibinfo.check output + format.date "year" output.check +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {proceedings} +{ output.bibitem + editor empty$ + { organization "organization" bibinfo.check output + } + { format.editors output.nonnull } + if$ + add.colon + new.block + format.btitle "title" output.check + format.bvolume output + editor empty$ + { publisher empty$ + { format.number.series output } + { + new.sentence + format.number.series output + format.publisher.address output + } + if$ + } + { publisher empty$ + { + new.sentence + format.number.series output + format.organization.address output } + { + new.sentence + format.number.series output + organization "organization" bibinfo.check output + format.publisher.address output + } + if$ + } + if$ + format.date "year" output.check +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {techreport} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.title + "title" output.check + new.block + format.tr.number output.nonnull + institution "institution" bibinfo.warn output + address "address" bibinfo.check output + format.date "year" output.check +% new.block + format.url output +% new.block + format.note output + fin.entry +} + +FUNCTION {unpublished} +{ output.bibitem + format.authors "author" output.check + add.colon + new.block + format.title "title" output.check + format.date output +% new.block + format.url output +% new.block + format.note "note" output.check + fin.entry +} + +FUNCTION {default.type} { misc } +READ +FUNCTION {sortify} +{ purify$ + "l" change.case$ +} +INTEGERS { len } +FUNCTION {chop.word} +{ 's := + 'len := + s #1 len substring$ = + { s len #1 + global.max$ substring$ } + 's + if$ +} +FUNCTION {sort.format.names} +{ 's := + #1 'nameptr := + "" + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr + "{ll{ }}{ ff{ }}{ jj{ }}" + format.name$ 't := + nameptr #1 > + { + " " * + namesleft #1 = t "others" = and + { "zzzzz" * } + { t sortify * } + if$ + } + { t sortify * } + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {sort.format.title} +{ 't := + "A " #2 + "An " #3 + "The " #4 t chop.word + chop.word + chop.word + sortify + #1 global.max$ substring$ +} +FUNCTION {author.sort} +{ author empty$ + { key empty$ + { "to sort, need author or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { author sort.format.names } + if$ +} +FUNCTION {author.editor.sort} +{ author empty$ + { editor empty$ + { key empty$ + { "to sort, need author, editor, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { editor sort.format.names } + if$ + } + { author sort.format.names } + if$ +} +FUNCTION {author.organization.sort} +{ author empty$ + { organization empty$ + { key empty$ + { "to sort, need author, organization, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { "The " #4 organization chop.word sortify } + if$ + } + { author sort.format.names } + if$ +} +FUNCTION {editor.organization.sort} +{ editor empty$ + { organization empty$ + { key empty$ + { "to sort, need editor, organization, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { "The " #4 organization chop.word sortify } + if$ + } + { editor sort.format.names } + if$ +} +FUNCTION {presort} +{ type$ "book" = + type$ "inbook" = + or + 'author.editor.sort + { type$ "proceedings" = + 'editor.organization.sort + { type$ "manual" = + 'author.organization.sort + 'author.sort + if$ + } + if$ + } + if$ + " " + * + year field.or.null sortify + * + " " + * + title field.or.null + sort.format.title + * + #1 entry.max$ substring$ + 'sort.key$ := +} +ITERATE {presort} +SORT +STRINGS { longest.label } +INTEGERS { number.label longest.label.width } +FUNCTION {initialize.longest.label} +{ "" 'longest.label := + #1 'number.label := + #0 'longest.label.width := +} +FUNCTION {longest.label.pass} +{ number.label int.to.str$ 'label := + number.label #1 + 'number.label := + label width$ longest.label.width > + { label 'longest.label := + label width$ 'longest.label.width := + } + 'skip$ + if$ +} +EXECUTE {initialize.longest.label} +ITERATE {longest.label.pass} +FUNCTION {begin.bib} +{ preamble$ empty$ + 'skip$ + { preamble$ write$ newline$ } + if$ + "\begin{thebibliography}{" longest.label * "}" * + write$ newline$ + "\providecommand{\url}[1]{\texttt{#1}}" + write$ newline$ + "\providecommand{\urlprefix}{URL }" + write$ newline$ +} +EXECUTE {begin.bib} +EXECUTE {init.state.consts} +ITERATE {call.type$} +FUNCTION {end.bib} +{ newline$ + "\end{thebibliography}" write$ newline$ +} +EXECUTE {end.bib} +%% End of customized bst file +%% +%% End of file `titto.bst'. + + diff --git a/doc/Rapport post-doc/sprmindx.sty b/doc/Rapport post-doc/sprmindx.sty new file mode 100644 index 0000000..8f17772 --- /dev/null +++ b/doc/Rapport post-doc/sprmindx.sty @@ -0,0 +1,4 @@ +delim_0 "\\idxquad " +delim_1 "\\idxquad " +delim_2 "\\idxquad " +delim_n ",\\," diff --git a/doc/Rapport post-doc/subjidx.ind b/doc/Rapport post-doc/subjidx.ind new file mode 100644 index 0000000..cd678e8 --- /dev/null +++ b/doc/Rapport post-doc/subjidx.ind @@ -0,0 +1,70 @@ +% clmomu01.ind +%----------------------------------------------------------------------- +% CLMoMu01 1.0: LaTeX style files for books +% Sample index file for User's guide +% (c) Springer-Verlag HD +%----------------------------------------------------------------------- +\begin{theindex} +\item Absorption\idxquad 327 +\item Absorption of radiation \idxquad 289--292,\, 299,\,300 +\item Actinides \idxquad 244 +\item Aharonov-Bohm effect\idxquad 142--146 +\item Angular momentum\idxquad 101--112 +\subitem algebraic treatment\idxquad 391--396 +\item Angular momentum addition\idxquad 185--193 +\item Angular momentum commutation relations\idxquad 101 +\item Angular momentum quantization\idxquad 9--10,\,104--106 +\item Angular momentum states\idxquad 107,\,321,\,391--396 +\item Antiquark\idxquad 83 +\item $\alpha$-rays\idxquad 101--103 +\item Atomic theory\idxquad 8--10,\,219--249,\,327 +\item Average value\newline ({\it see also\/} Expectation value) +15--16,\,25,\,34,\,37,\,357 +\indexspace +\item Baker-Hausdorff formula\idxquad 23 +\item Balmer formula\idxquad 8 +\item Balmer series\idxquad 125 +\item Baryon\idxquad 220,\,224 +\item Basis\idxquad 98 +\item Basis system\idxquad 164,\,376 +\item Bell inequality\idxquad 379--381,\,382 +\item Bessel functions\idxquad 201,\,313,\,337 +\subitem spherical\idxquad 304--306,\, 309,\, 313--314,\,322 +\item Bound state\idxquad 73--74,\,78--79,\,116--118,\,202,\, 267,\, +273,\,306,\,348,\,351 +\item Boundary conditions\idxquad 59,\, 70 +\item Bra\idxquad 159 +\item Breit-Wigner formula\idxquad 80,\,84,\,332 +\item Brillouin-Wigner perturbation theory\idxquad 203 +\indexspace +\item Cathode rays\idxquad 8 +\item Causality\idxquad 357--359 +\item Center-of-mass frame\idxquad 232,\,274,\,338 +\item Central potential\idxquad 113--135,\,303--314 +\item Centrifugal potential\idxquad 115--116,\,323 +\item Characteristic function\idxquad 33 +\item Clebsch-Gordan coefficients\idxquad 191--193 +\item Cold emission\idxquad 88 +\item Combination principle, Ritz's\idxquad 124 +\item Commutation relations\idxquad 27,\,44,\,353,\,391 +\item Commutator\idxquad 21--22,\,27,\,44,\,344 +\item Compatibility of measurements\idxquad 99 +\item Complete orthonormal set\idxquad 31,\,40,\,160,\,360 +\item Complete orthonormal system, {\it see}\newline +Complete orthonormal set +\item Complete set of observables, {\it see\/} Complete +set of operators +\indexspace +\item Eigenfunction\idxquad 34,\,46,\,344--346 +\subitem radial\idxquad 321 +\subsubitem calculation\idxquad 322--324 +\item EPR argument\idxquad 377--378 +\item Exchange term\idxquad 228,\,231,\,237,\,241,\,268,\,272 +\indexspace +\item $f$-sum rule\idxquad 302 +\item Fermi energy\idxquad 223 +\indexspace +\item H$^+_2$ molecule\idxquad 26 +\item Half-life\idxquad 65 +\item Holzwarth energies\idxquad 68 +\end{theindex} diff --git a/doc/Rapport post-doc/tina.bib b/doc/Rapport post-doc/tina.bib new file mode 100644 index 0000000..438a6a5 --- /dev/null +++ b/doc/Rapport post-doc/tina.bib @@ -0,0 +1,103 @@ +@article{berthomieu2004tool, + title={The tool {TINA}--Construction of Abstract State Spaces for Petri nets and Time Petri nets}, + author={Berthomieu, Bernard and Ribet, P-O and Vernadat, Fran{\c{c}}ois}, + journal={International Journal of Production Research}, + volume={42}, + number={14}, + year={2004} +} + +@inproceedings{berthomieu2008fiacre, + title={Fiacre: an intermediate language for model verification in the topcased environment}, + author={Berthomieu, Bernard and Bodeveix, Jean-Paul and Farail, Patrick and Filali, Mamoun and Garavel, Hubert and Gaufillet, Pierre and Lang, Frederic and Vernadat, Fran{\c{c}}ois}, + booktitle={ERTS 2008}, + year={2008} +} + +@inproceedings{berthomieu2010formal, + title={Formal Verification of AADL models with Fiacre and Tina}, + author={Berthomieu, Bernard and Bodeveix, Jean-Paul and Dal Zilio, Silvano and Dissaux, Pierre and Filali, Mamoun and Gaufillet, Pierre and Heim, Sebastien and Vernadat, Fran{\c{c}}ois}, + booktitle={ERTSS 2010-Embedded Real-Time Software and Systems}, + pages={1--9}, + year={2010} +} + +@Article{BM83, + author = "B. Berthomieu and M. Menasche", + title = "An Enumerative Approach for Analyzing Time {P}etri Nets.", + journal = "IFIP Congress Series", + volume = "9", + pages = "41--46", + publisher = "Elsevier Science Publ. Comp. (North Holland)", + year = "1983", +} + +@Article{BRV04, + author = {Berthomieu, B. and Ribet, P.O. and Vernadat, F.}, + title = {The tool {T}INA -- Construction of Abstract State Spaces for {P}etri + {N}ets and Time Petri Nets}, + journal = {International Journal of Production Research}, + volume = 42, + number = 14, + year = 2004} + +@incollection{berthomieu2014model, + title={Model-Checking Real-Time Properties of an Aircraft Landing Gear System Using Fiacre}, + author={Berthomieu, B. and Dal Zilio, S. and Fronc, {\L}.}, + booktitle={ABZ 2014: The Landing Gear Case Study}, + pages={110--125}, + year={2014}, + publisher={Springer} +} + +@article{zilio2015latency, + title={Latency Analysis of an Aerial Video Tracking System Using Fiacre and Tina}, + author={Dal Zilio, S. and Berthomieu, B. and Le Botlan, D.}, + journal={arXiv preprint arXiv:1509.06506}, + year={2015} +} + +@inproceedings{bourdil2014model, + title={Model-Checking Real-Time Properties of an Auto Flight Control System Function}, + author={Bourdil, P.-A. and Berthomieu, B. and Jenn, E.}, + booktitle={IEEE ISSREW}, + year={2014} +} + +@article{rangra2014sdl, + title={{SDL} to {Fiacre} translation}, + author={Rangra, S. and Gaudin, E.}, + journal={Embedded Real-Time Software and Systems, Toulouse}, + year={2014} +} + +@article{bouyer2004updatable, + title={Updatable timed automata}, + author={Bouyer, Patricia and Dufourd, Catherine and Fleury, Emmanuel and Petit, Antoine}, + journal={Theoretical Computer Science}, + volume={321}, + number={2-3}, + pages={291--345}, + year={2004}, + publisher={Elsevier} +} + +@article{larsen1997uppaal, + title={UPPAAL in a nutshell}, + author={Larsen, Kim G and Pettersson, Paul and Yi, Wang}, + journal={International journal on software tools for technology transfer}, + volume={1}, + number={1-2}, + pages={134--152}, + year={1997}, + publisher={Springer} +} + +@inproceedings{griffault2004mec, + title={The mec 5 model-checker}, + author={Griffault, Alain and Vincent, Aymeric}, + booktitle={International Conference on Computer Aided Verification}, + pages={488--491}, + year={2004}, + organization={Springer} +} \ No newline at end of file diff --git a/doc/TODO b/doc/TODO new file mode 100644 index 0000000..677a421 --- /dev/null +++ b/doc/TODO @@ -0,0 +1 @@ +nettoyer les diracs: on fait des calculs de proba des mev inutiles juste pour bouffer les diracs \ No newline at end of file diff --git a/doc/altarica-syntax.pdf b/doc/altarica-syntax.pdf new file mode 100644 index 0000000..b413d7b Binary files /dev/null and b/doc/altarica-syntax.pdf differ diff --git a/doc/boundedcont.pdf b/doc/boundedcont.pdf new file mode 100644 index 0000000..67b903f Binary files /dev/null and b/doc/boundedcont.pdf differ diff --git a/doc/cont.pdf b/doc/cont.pdf new file mode 100644 index 0000000..8cb9f15 Binary files /dev/null and b/doc/cont.pdf differ diff --git a/doc/quickstart.aux b/doc/quickstart.aux new file mode 100644 index 0000000..1a8ce2d --- /dev/null +++ b/doc/quickstart.aux @@ -0,0 +1,22 @@ +\relax +\@writefile{toc}{\contentsline {section}{\numberline {1}Preliminaries}{1}} +\@writefile{toc}{\contentsline {section}{\numberline {2}Use}{2}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Model file}{2}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Init file}{2}} +\newlabel{init}{{2.2}{3}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Query specification}{3}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Algorithm selection}{4}} +\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.1}Discrete time}{4}} +\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Continuous time}{4}} +\@writefile{toc}{\contentsline {section}{\numberline {3}Output}{5}} +\@writefile{toc}{\contentsline {subsection}{\numberline {3.1}Textual output}{5}} +\@writefile{toc}{\contentsline {subsection}{\numberline {3.2}Graphical output for continuous time algorithms}{6}} +\newlabel{nobounds}{{1(a)}{6}} +\newlabel{sub@nobounds}{{(a)}{6}} +\newlabel{bounds}{{1(b)}{6}} +\newlabel{sub@bounds}{{(b)}{6}} +\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces Output examples for continuous time algorithms}}{6}} +\@writefile{lof}{\contentsline {subfigure}{\numberline{(a)}{\ignorespaces {no bounds}}}{6}} +\@writefile{lof}{\contentsline {subfigure}{\numberline{(b)}{\ignorespaces {bounds}}}{6}} +\newlabel{output}{{1}{6}} +\@writefile{toc}{\contentsline {section}{\numberline {4}Note on queries}{6}} diff --git a/doc/quickstart.log b/doc/quickstart.log new file mode 100644 index 0000000..bca5948 --- /dev/null +++ b/doc/quickstart.log @@ -0,0 +1,246 @@ +This is pdfTeX, Version 3.14159265-2.6-1.40.16 (TeX Live 2015/Debian) (preloaded format=pdflatex 2016.4.22) 5 OCT 2016 17:43 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +**quickstart.tex +(./quickstart.tex +LaTeX2e <2016/02/01> +Babel <3.9q> and hyphenation patterns for 5 language(s) loaded. +(/usr/share/texlive/texmf-dist/tex/latex/base/article.cls +Document Class: article 2014/09/29 v1.4h Standard LaTeX document class +(/usr/share/texlive/texmf-dist/tex/latex/base/size10.clo +File: size10.clo 2014/09/29 v1.4h Standard LaTeX file (size option) +) +\c@part=\count79 +\c@section=\count80 +\c@subsection=\count81 +\c@subsubsection=\count82 +\c@paragraph=\count83 +\c@subparagraph=\count84 +\c@figure=\count85 +\c@table=\count86 +\abovecaptionskip=\skip41 +\belowcaptionskip=\skip42 +\bibindent=\dimen102 +) +(/usr/share/texlive/texmf-dist/tex/latex/tools/verbatim.sty +Package: verbatim 2014/10/28 v1.5q LaTeX2e package for verbatim enhancements +\every@verbatim=\toks14 +\verbatim@line=\toks15 +\verbatim@in@stream=\read1 +) +(/usr/share/texlive/texmf-dist/tex/latex/subfigure/subfigure.sty +Package: subfigure 2002/03/15 v2.1.5 subfigure package +\subfigtopskip=\skip43 +\subfigcapskip=\skip44 +\subfigcaptopadj=\dimen103 +\subfigbottomskip=\skip45 +\subfigcapmargin=\dimen104 +\subfiglabelskip=\skip46 +\c@subfigure=\count87 +\c@lofdepth=\count88 +\c@subtable=\count89 +\c@lotdepth=\count90 + +**************************************** +* Local config file subfigure.cfg used * +**************************************** +(/usr/share/texlive/texmf-dist/tex/latex/subfigure/subfigure.cfg) +\subfig@top=\skip47 +\subfig@bottom=\skip48 +) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphicx.sty +Package: graphicx 2014/10/28 v1.0g Enhanced LaTeX Graphics (DPC,SPQR) + +(/usr/share/texlive/texmf-dist/tex/latex/graphics/keyval.sty +Package: keyval 2014/10/28 v1.15 key=value parser (DPC) +\KV@toks@=\toks16 +) +(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphics.sty +Package: graphics 2016/01/03 v1.0q Standard LaTeX Graphics (DPC,SPQR) + +(/usr/share/texlive/texmf-dist/tex/latex/graphics/trig.sty +Package: trig 2016/01/03 v1.10 sin cos tan (DPC) +) +(/usr/share/texlive/texmf-dist/tex/latex/latexconfig/graphics.cfg +File: graphics.cfg 2010/04/23 v1.9 graphics configuration of TeX Live +) +Package graphics Info: Driver file: pdftex.def on input line 95. + +(/usr/share/texlive/texmf-dist/tex/latex/pdftex-def/pdftex.def +File: pdftex.def 2011/05/27 v0.06d Graphics/color for pdfTeX + +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/infwarerr.sty +Package: infwarerr 2010/04/08 v1.3 Providing info/warning/error messages (HO) +) +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/ltxcmds.sty +Package: ltxcmds 2011/11/09 v1.22 LaTeX kernel commands for general use (HO) +) +\Gread@gobject=\count91 +)) +\Gin@req@height=\dimen105 +\Gin@req@width=\dimen106 +) +(./quickstart.aux) +\openout1 = `quickstart.aux'. + +LaTeX Font Info: Checking defaults for OML/cmm/m/it on input line 12. +LaTeX Font Info: ... okay on input line 12. +LaTeX Font Info: Checking defaults for T1/cmr/m/n on input line 12. +LaTeX Font Info: ... okay on input line 12. +LaTeX Font Info: Checking defaults for OT1/cmr/m/n on input line 12. +LaTeX Font Info: ... okay on input line 12. +LaTeX Font Info: Checking defaults for OMS/cmsy/m/n on input line 12. +LaTeX Font Info: ... okay on input line 12. +LaTeX Font Info: Checking defaults for OMX/cmex/m/n on input line 12. +LaTeX Font Info: ... okay on input line 12. +LaTeX Font Info: Checking defaults for U/cmr/m/n on input line 12. +LaTeX Font Info: ... okay on input line 12. + +(/usr/share/texlive/texmf-dist/tex/context/base/supp-pdf.mkii +[Loading MPS to PDF converter (version 2006.09.02).] +\scratchcounter=\count92 +\scratchdimen=\dimen107 +\scratchbox=\box26 +\nofMPsegments=\count93 +\nofMParguments=\count94 +\everyMPshowfont=\toks17 +\MPscratchCnt=\count95 +\MPscratchDim=\dimen108 +\MPnumerator=\count96 +\makeMPintoPDFobject=\count97 +\everyMPtoPDFconversion=\toks18 +) (/usr/share/texlive/texmf-dist/tex/generic/oberdiek/pdftexcmds.sty +Package: pdftexcmds 2011/11/29 v0.20 Utility functions of pdfTeX for LuaTeX (HO +) + +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/ifluatex.sty +Package: ifluatex 2010/03/01 v1.3 Provides the ifluatex switch (HO) +Package ifluatex Info: LuaTeX not detected. +) +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/ifpdf.sty +Package: ifpdf 2011/01/30 v2.3 Provides the ifpdf switch (HO) +Package ifpdf Info: pdfTeX in PDF mode is detected. +) +Package pdftexcmds Info: LuaTeX not detected. +Package pdftexcmds Info: \pdf@primitive is available. +Package pdftexcmds Info: \pdf@ifprimitive is available. +Package pdftexcmds Info: \pdfdraftmode found. +) +(/usr/share/texlive/texmf-dist/tex/latex/oberdiek/epstopdf-base.sty +Package: epstopdf-base 2010/02/09 v2.5 Base part for package epstopdf + +(/usr/share/texlive/texmf-dist/tex/latex/oberdiek/grfext.sty +Package: grfext 2010/08/19 v1.1 Manage graphics extensions (HO) + +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/kvdefinekeys.sty +Package: kvdefinekeys 2011/04/07 v1.3 Define keys (HO) +)) +(/usr/share/texlive/texmf-dist/tex/latex/oberdiek/kvoptions.sty +Package: kvoptions 2011/06/30 v3.11 Key value format for package options (HO) + +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/kvsetkeys.sty +Package: kvsetkeys 2012/04/25 v1.16 Key value parser (HO) + +(/usr/share/texlive/texmf-dist/tex/generic/oberdiek/etexcmds.sty +Package: etexcmds 2011/02/16 v1.5 Avoid name clashes with e-TeX commands (HO) +Package etexcmds Info: Could not find \expanded. +(etexcmds) That can mean that you are not using pdfTeX 1.50 or +(etexcmds) that some package has redefined \expanded. +(etexcmds) In the latter case, load this package earlier. +))) +Package grfext Info: Graphics extension search list: +(grfext) [.png,.pdf,.jpg,.mps,.jpeg,.jbig2,.jb2,.PNG,.PDF,.JPG,.JPE +G,.JBIG2,.JB2,.eps] +(grfext) \AppendGraphicsExtensions on input line 452. + +(/usr/share/texlive/texmf-dist/tex/latex/latexconfig/epstopdf-sys.cfg +File: epstopdf-sys.cfg 2010/07/13 v1.3 Configuration of (r)epstopdf for TeX Liv +e +)) +LaTeX Font Info: External font `cmex10' loaded for size +(Font) <12> on input line 14. +LaTeX Font Info: External font `cmex10' loaded for size +(Font) <8> on input line 14. +LaTeX Font Info: External font `cmex10' loaded for size +(Font) <6> on input line 14. +LaTeX Font Info: Try loading font information for OMS+cmr on input line 26. + +(/usr/share/texlive/texmf-dist/tex/latex/base/omscmr.fd +File: omscmr.fd 2014/09/29 v2.5h Standard LaTeX font definitions +) +LaTeX Font Info: Font shape `OMS/cmr/m/n' in size <10> not available +(Font) Font shape `OMS/cmsy/m/n' tried instead on input line 26. + [1 + +{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}] +LaTeX Font Info: External font `cmex10' loaded for size +(Font) <7> on input line 77. +LaTeX Font Info: External font `cmex10' loaded for size +(Font) <5> on input line 77. + [2] [3] [4] +Overfull \hbox (15.9971pt too wide) in paragraph at lines 270--270 + []\OT1/cmtt/m/n/10 Check [recall of user selected algorithm] (Pr[f1Uf2](0,h) > += t):[] + [] + + +Overfull \hbox (15.9971pt too wide) in paragraph at lines 287--287 + []\OT1/cmtt/m/n/10 probability: [either a value for unbounded versions or some +thing[] + [] + +[5] +File: cont.pdf Graphic file (type pdf) + +Package pdftex.def Info: cont.pdf used on input line 323. +(pdftex.def) Requested size: 172.5pt x 128.6861pt. + + +File: boundedcont.pdf Graphic file (type pdf) + +Package pdftex.def Info: boundedcont.pdf used on input line 327. +(pdftex.def) Requested size: 155.24895pt x 128.45428pt. + +[6 <./cont.pdf> <./boundedcont.pdf>] +Overfull \hbox (16.25519pt too wide) in paragraph at lines 376--376 +[] \OT1/cmtt/m/n/8 [] + [] + + +Overfull \hbox (7.75507pt too wide) in paragraph at lines 382--382 +[] \OT1/cmtt/m/n/8 [] + [] + +[7] (./quickstart.aux) ) +Here is how much of TeX's memory you used: + 1717 strings out of 494924 + 24547 string characters out of 6179708 + 81319 words of memory out of 5000000 + 5004 multiletter control sequences out of 15000+600000 + 8577 words of font info for 31 fonts, out of 8000000 for 9000 + 14 hyphenation exceptions out of 8191 + 37i,6n,24p,236b,297s stack positions out of 5000i,500n,10000p,200000b,80000s +< +/usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb> +Output written on quickstart.pdf (7 pages, 254520 bytes). +PDF statistics: + 92 PDF objects out of 1000 (max. 8388607) + 64 compressed objects within 1 object stream + 0 named destinations out of 1000 (max. 500000) + 11 words of extra memory for PDF output out of 10000 (max. 10000000) + diff --git a/doc/quickstart.pdf b/doc/quickstart.pdf new file mode 100644 index 0000000..591f018 Binary files /dev/null and b/doc/quickstart.pdf differ diff --git a/doc/quickstart.tex b/doc/quickstart.tex new file mode 100644 index 0000000..caff287 --- /dev/null +++ b/doc/quickstart.tex @@ -0,0 +1,407 @@ +\documentclass[a4paper]{article} + +%\usepackage{a4wide} +\usepackage{verbatim} +\usepackage{subfigure} +\usepackage{graphicx} + +\title{Epoch QuickStart guide} +\author{Guillaume Infantes} +\date{January 21, 2013} + +\begin{document} + +\maketitle + +This guide describes usage of EPOCH temporal probabilistic assessment +tool as of version 20130121. + +\section{Preliminaries} + +Epoch aims at ensuring the \emph{validity} of \emph{temporal + properties} from an \emph{initial state} of a given +\emph{dynamic model}. + +\begin{itemize} +\item The \emph{validity} is simply a true/false value output as a 1 + or 0. +\item The \emph{temporal property} is for now only a small subset of + PTCL* (more on this below). +\item The \emph{dynamic model} of the system is given as an AltaRica + file, that can be directly exported from modelling/assessment tools + like OCAS or others. +\item The \emph{initial state} may be specified directly in the + dynamic model itself (``init'' keyword of AltaRica + files, can be given from the tool used to build the model itself); + or it can be specified as a separate file (see section \ref{init}). +\end{itemize} + +For version 20130121, time can have two very different semantics: +\begin{itemize} +\item First is an ``abstract'' notion meaning a timestep, that is +any change in the system. It is denoted \emph{discrete} time. +\item Second is the natural time, meaning a real time in + seconds/hours. It is denoted \emph{continuous} time. +\end{itemize} + +\subsection*{Temporal properties} + +A temporal property is generally a property on possible execution +paths of the dynamic model (see technical report DCSD-T/R-120/11 for a +general presentation). Epoch currently handles only simples +constructs that should be sufficient for DIANA needs. We call a \emph{query} the +asking for a check of a temporal property. + +An example of query is: ``is the probability that variable FC\_x takes the +value true whithin 3 time units greater than 10e-9 ?''. + +\begin{itemize} +\item For discrete version the time unit is a timestep, +i.e. a (non-immediate) change in the system. This means +that if the model is a failure propagation model, then 3 timesteps +means 3 failure events. Immediate events are denoted +``dirac(0)'' and are not taken into account for the horizon, as they +are used for ease of modelling in order to make the tool compute the +state of the system for non-trivial updates. For instance, in the +Bleed model, many dirac(0) updates are necessary to compute the +resulting pressures after any event, while these intermediate states do +not have any physical reality. +\item For continuous time, the semantic of time is the intuitive one. The +unit is not specified, it just has to be consistent over the model and +the queries. +\end{itemize} + + + +Formally, the previous queries can be written as: +\begin{displaymath} + ? P_{\le{3}}(true~Until~FC\_x=true) \ge 10^{-9} +\end{displaymath} + +We will see in next section how to specify such query within EPOCH. + + +\section{Use} + + +\verb?--help? gives description of command-line options.\\ +\verb?--verbosity? changes text output information level. + +\subsection{Model file} + +\verb?--file? gives the name of the dynamic model +(including initial state) to check. As files are not searched in any +particular directory (except current directory), we strongly encourage +to give full qualified names.\\ Example: \verb?--file $HOME/model.alt? + +\subsection{Init file} +\verb?--init? allows to give path to a xml file specifying initial +values. If initial values are specified both in model and init file, +init file values are used. +An example is show below: +{\footnotesize +\begin{verbatim} + + + + Rudder_BPS_RB + class + + + + + + + + + main.BCM + + + + + + + + +\end{verbatim} +} +The user has to specify the nodes where init values has to be set, +using the \verb?? tag. +Inside a node, several fields have to be specified: +\begin{itemize} +\item \verb?node_name?: specifies the name of the + node. It can be: + \begin{itemize} + \item an instance, and so the full + name has to be given, as for \verb?main.BCM? (in this case + \verb?instance? is assumed as default) + \item a node definition (will affect all its instances). In + this case, the \verb?class? has to be + added (\verb?Rudder_BPS_RB? example). + \end{itemize} +\item \verb?? allows to change event law, specified by a list of + tags with the syntax \verb??; where +\verb?ename? is the event name inside the node, \verb?law? can be \verb?dirac? or \verb?exp?, +and \verb?val? can be \verb?0? (for diracs) or any double (for +exponential law rates). Doubles can be stated as \verb?1.5E-5? for example. +\item \verb?? start a list of initial values stated with the + following general syntax: + \verb??, where \verb?varName? + is the name of the variable (a string) and \verb?varValue? its + initial value (also a string). +\end{itemize} +\label{init} + +The complete XSD definition is given at the end of the document. + +\subsection{Query specification} + +As the query is quite complicated, several switches are mandatory for +query specification. In the following , we will use $? +P_{\le{3}}(true~Until~FC\_x=true) \ge 10^{-9}$ as an example. + + +\subsubsection*{Variable} +\verb?--var? gives the name of the variable to check. The variable name has to be the full qualified +\emph{case-senstive} AltaRica name of the variable instance. \\Example: +\verb? --var main.LGERS.SAFETY.fc_safety^FC15? (from A380 LGERS model) + +\subsubsection*{Value} +\verb?--value? value of the variable. For string/enum values, the +argument is \emph{case-sensitive}.\\ Examples: ``\verb?--value true?'' ``\verb?--value OK?'' + +\subsubsection*{Time horizon} +\verb?--dhor? specify time horizon for discrete time property checking. \\Example: +\verb?--dhor 3?\\ +\verb?--chor? specify time horizon for continuous time property checking. \\Example: +\verb?--chor 3? + + +\subsubsection*{Probability threshold} +\verb?--thres? threshold for probability. \\Example: +\verb?--thres 10e-9? + +\subsubsection*{Negation of the property} +\verb?--neg? specifies $\neq$ instead of $=$ for the inner property. For example, if +FC\_x can be ``false'', ``true'' or ``dont\_know'', and both ``true'' and ``dont\_know'' +are problematic, then the property to check is FC\_x $\neq$ false and +one has to call EPOCH with:\\ \verb?--var FC_x --value false --neg? + +\subsection{Algorithm selection} + +Several algorithms can be used by EPOCH. They are selected with the + +\verb?--algo? switch. + +\verb?-1? runs all algorithms one after the other (usefull + only for testing purposes). +\subsubsection{Discrete time} +\begin{itemize} +\item \verb?0? runs exact computation over infinite time (do not + honor \verb?--dhor? switch). Not usefull for DIANA. +\item \verb?1? runs iterative computation over infinite time (do not + honor \verb?--dhor? switch). Not usefull for DIANA. +\item \verb?2? runs exact computation over infinite time using + bound mechanism (do not honor \verb?--dhor? switch). Not usefull + for DIANA. +\item \verb?3? runs iterative computation over infinite time using + bound mechanism (do not honor \verb?--dhor? switch). Not usefull + for DIANA. +\item \verb?4? runs exact computation over finite time specified + by \verb?--dhor? switch. +\item \verb?5? (default) runs exact computation over finite time specified + by \verb?--dhor? switch, using the bound mechanism. +\end{itemize} + +Algorithm 5 is designed to be the most efficient and should be used +for DIANA for discrete time computations. + +\subsubsection{Continuous time} +\begin{itemize} +\item \verb?6? runs exact computation without bounding mechanism. +\item \verb?7? runs exact computation with bounding mechanism. +\end{itemize} + +These algorithms comes with different implementations for internal +Hessenberg matrices, that can be changed using the \verb?--hess? +switch. + +\begin{itemize} +\item \verb?0? triangular Hessenberg matrices +\item \verb?1? banded Hessenberg matrices +\item \verb?2? dense Hessenberg matrices +\end{itemize} + +Default value is \verb?0?, this aims to be the most efficient version. + +\section{Output} + +\subsection{Textual output} + +Currently, default output gives the following informations: + +\begin{itemize} +\item +\begin{verbatim} +f1: true +\end{verbatim} +Generally, we check $f1~Until~f2$ formulas, but for now f1 is always true; +\item +\begin{verbatim} +f2: P +\end{verbatim} + where P is the property to check (defined with \verb?--var?, \verb?--value?, \verb?--neg?); +\item then some data about the model are given: +\begin{verbatim} +MODEL STATS: +number of state vars: s +number of _different_ flow vars: f +number of atomic events: e +\end{verbatim} +s is the total number of states variables in the fully instanciated model; f +is the number of different flow variables (for assertions of type +$v1=v2$, only one instance is considered); e is the number of events +(generally failures), including dirac(0) but not taking into account +synchronizations. +\item +\begin{verbatim} +Check [recall of user selected algorithm] (Pr[f1Uf2](0,h) >= t): +\end{verbatim} +where h is the horizon given by \verb?--hor? and t is the probability +threshold given by \verb?--thres?. \\ +For continuous time algorithms, the probability at specified time is +given once here: \verb?PROB: xx.xxx? +\\The following 0 or 1 is the +result for the query; 0 for false, 1 for true. \emph{For + scripting purposes, this value is also given to the shell as an + exit value} \verb!$?!. +\item +\begin{verbatim} +time taken: n seconds +\end{verbatim} +n is the time taken by the execution (if alone); +\item +\begin{verbatim} +probability: [either a value for unbounded versions or something +like:] [ {([0,10]->0)} ; {([0,10]->0)} ] +\end{verbatim} + gives the probabilities as intervals. The format for bounded + version is + [l,u], where l is the lower bound, u the upper, and l,u are given as + interval/value sequences, $\{(i_1) (i_2) \ldots\}$, whith $i_i$ of the form + \verb![a,b] -> p!, meaning that from timestep $a$ to timestep $b$, the + probability of the property is $p$. +\item +\begin{verbatim} +explored states: n +\end{verbatim} + here n is the total number of states + that EPOCH had to instanciate in order to answer the query. +\end{itemize} + + +\subsection{Graphical output for continuous time algorithms} +For continuous time algorithms, a graphical view of the analytical +solution is displayed, as shown on figure \ref{output}. + +In these figures, x-axis is time, y-axis is probability, vertical bold +yellow line shows time horizon specified by the query. + +In unbounded version (figure \ref{nobounds}), the red line show the +evolution of the probability of the specified property with time. +In bounded version, as in example of figure \ref{bounds}, the red and +blue curves show the enveloppe of the +true probability which is sufficient to answer the query. + +\begin{figure}[ht] +\begin{center} + \subfigure[no bounds]{ + \includegraphics[width=.5\textwidth]{cont} + \label{nobounds} + } + \subfigure[bounds]{ + \includegraphics[width=.45\textwidth]{boundedcont} + \label{bounds} + } + \end{center} +\caption{Output examples for continuous time algorithms} +\label{output} +\end{figure} + + +\section{Note on queries} +Due to the bound mechanism used by the ``bounded'' algorithms, it can +be interesting to ask for the complementary query, depending on the +model. For instance, $?P_{\le{3}}(true~Until~FC\_x\neq true) \le +1-10^{-9}$ gives the same information as $?P_{\le{3}}(true~Until~ +FC\_x=true) \le 10^{-9}$. Depending on the model, these +two queries may need very different computation times. + +\newpage +\section*{XSD definition of init files} +\footnotesize{ +\begin{verbatim} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +\end{verbatim} +} + +\end{document} diff --git a/icons/document-build-model-16.xpm b/icons/document-build-model-16.xpm new file mode 100644 index 0000000..3c722d4 --- /dev/null +++ b/icons/document-build-model-16.xpm @@ -0,0 +1,162 @@ +/* XPM */ +static const char * document_build_model_16_xpm[] = { +"16 16 143 2", +" c None", +". c #5EBF25", +"+ c #88D159", +"@ c #B4E493", +"# c #7BC65C", +"$ c #53BA1A", +"% c #92E23E", +"& c #A3F239", +"* c #A1F039", +"= c #88DB3B", +"- c #61BD36", +"; c #128809", +"> c #41B100", +", c #92E23F", +"' c #A1F724", +") c #BBFF4D", +"! c #B6FF40", +"~ c #99EF26", +"{ c #64C61F", +"] c #168E01", +"^ c #36A700", +"/ c #7DD72B", +"( c #B8FA59", +"_ c #E2FFB3", +": c #C8FD77", +"< c #9AE840", +"[ c #4CB80D", +"} c #0E8700", +"| c #1D9100", +"1 c #41B400", +"2 c #7ED72D", +"3 c #AAE869", +"4 c #9ADF60", +"5 c #61C224", +"6 c #269D00", +"7 c #017D00", +"8 c #48820A", +"9 c #3FA429", +"0 c #73C549", +"a c #9EDB76", +"b c #8CD361", +"c c #5CB838", +"d c #239118", +"e c #007B00", +"f c #6DA8F7", +"g c #5691E1", +"h c #FEC33B", +"i c #FFC45B", +"j c #FFCD77", +"k c #7AA63A", +"l c #79C26E", +"m c #A7D796", +"n c #98D185", +"o c #66B54D", +"p c #3DA970", +"q c #74D2EF", +"r c #7DD8FE", +"s c #7CD4FF", +"t c #59ACF2", +"u c #F9CB30", +"v c #FEE64B", +"w c #FFE23B", +"x c #FEDD3C", +"y c #FFD93C", +"z c #C0BF29", +"A c #85C383", +"B c #80B757", +"C c #31CAC9", +"D c #45D9FF", +"E c #44E6FE", +"F c #46E7FF", +"G c #3EDAFF", +"H c #43C8FF", +"I c #34B1F8", +"J c #F7C424", +"K c #FFE769", +"L c #FFF96F", +"M c #FFFE5C", +"N c #FFFC6A", +"O c #FFF36A", +"P c #EDDD30", +"Q c #C7BF34", +"R c #45DEC3", +"S c #75F6FF", +"T c #7AFCFF", +"U c #7DFDFF", +"V c #6BF4FF", +"W c #56E3FF", +"X c #27BEFF", +"Y c #F7BA22", +"Z c #FFD534", +"` c #FFED71", +" . c #FFF292", +".. c #FFE876", +"+. c #FFE45A", +"@. c #E4CD21", +"#. c #C1B232", +"$. c #1DBFC4", +"%. c #5EE0FF", +"&. c #84EFFE", +"*. c #88E7FB", +"=. c #76DCFA", +"-. c #31C8FF", +";. c #1FA6FB", +">. c #F7A81B", +",. c #FEC32D", +"'. c #FFD553", +"). c #FFE082", +"!. c #FFDD78", +"~. c #FFC944", +"{. c #E2B51F", +"]. c #BD9A2B", +"^. c #1398BE", +"/. c #3DBFFF", +"(. c #73D3FE", +"_. c #81D8FE", +":. c #58C4FD", +"<. c #299EF4", +"[. c #136ADB", +"}. c #FEC04E", +"|. c #FED979", +"1. c #FFE293", +"2. c #FFDB80", +"3. c #FFD067", +"4. c #E0AE2D", +"5. c #946611", +"6. c #1E6199", +"7. c #6DB8F7", +"8. c #84CAF9", +"9. c #8ACEF9", +"0. c #69B6F2", +"a. c #468BE3", +"b. c #0B2DA6", +"c. c #EDAF57", +"d. c #FFEAB7", +"e. c #FFD78E", +"f. c #C88D38", +"g. c #2946A2", +"h. c #9AB6E7", +"i. c #ABC7ED", +"j. c #506CBE", +"k. c #BA6F2B", +"l. c #1C1F6B", +" ", +" . + @ # ", +" $ % & * = - ; ", +" > , ' ) ! ~ { ] ", +" ^ / ( _ : < [ } ", +" | 1 2 3 4 5 6 7 ", +" 8 9 0 a b c d e f g ", +" h i j k l m n o p q r s t ", +"u v w x y z A B C D E F G H I ", +"J K L M N O P Q R S T U V W X ", +"Y Z ` ...+.@.#.$.%.&.*.=.-.;. ", +">.,.'.).!.~.{.].^./.(._.:.<.[. ", +" }.|.1.2.3.4.5.6.7.8.9.0.a.b. ", +" c.d.e.f. g.h.i.j. ", +" k. l. ", +" "}; diff --git a/icons/document-build-model-24.xpm b/icons/document-build-model-24.xpm new file mode 100644 index 0000000..014cefb --- /dev/null +++ b/icons/document-build-model-24.xpm @@ -0,0 +1,343 @@ +/* XPM */ +static const char * document_build_model_24_xpm[] = { +"24 24 316 2", +" c None", +". c #76C454", +"+ c #80C66B", +"@ c #55B03B", +"# c #74CA3D", +"$ c #9EDD70", +"% c #A6E178", +"& c #A8E07E", +"* c #98D675", +"= c #64B945", +"- c #178E00", +"; c #41AE12", +"> c #7DD040", +", c #97E24B", +"' c #A0EB48", +") c #A4EE48", +"! c #9EE848", +"~ c #8FDD48", +"{ c #7FCE4C", +"] c #57B439", +"^ c #128907", +"/ c #44B309", +"( c #68C820", +"_ c #7BDA1B", +": c #91F10E", +"< c #A7FC23", +"[ c #ADFE2E", +"} c #A2FA1B", +"| c #88E90F", +"1 c #72D31C", +"2 c #58BB23", +"3 c #27990E", +"4 c #047200", +"5 c #45B700", +"6 c #96E14C", +"7 c #A1F038", +"8 c #B4FD41", +"9 c #BDFF54", +"0 c #C8FF72", +"a c #BAFF4B", +"b c #AFF941", +"c c #85DD2E", +"d c #55BD15", +"e c #209701", +"f c #046C00", +"g c #3DB000", +"h c #79D42A", +"i c #AAF052", +"j c #BBFD54", +"k c #DFFFAB", +"l c #E9FFC7", +"m c #CCFD80", +"n c #9EEF36", +"o c #7FD730", +"p c #43B308", +"q c #199200", +"r c #016A00", +"s c #2FA400", +"t c #50BE05", +"u c #80DB28", +"v c #ADF158", +"w c #B6F758", +"x c #BFF47A", +"y c #ABEC61", +"z c #92DD4D", +"A c #5AC311", +"B c #30A400", +"C c #0D8800", +"D c #006800", +"E c #1A9200", +"F c #35A900", +"G c #51BE04", +"H c #80D538", +"I c #9ADF5A", +"J c #A6E36D", +"K c #9ADD66", +"L c #6AC431", +"M c #38A909", +"N c #017E00", +"O c #078100", +"P c #2A9A13", +"Q c #5AB733", +"R c #76C946", +"S c #92D863", +"T c #A1DD75", +"U c #8CD35F", +"V c #62BD37", +"W c #3EA523", +"X c #12880B", +"Y c #007D00", +"Z c #0D753E", +"` c #3F82DF", +" . c #3573D6", +".. c #FFB458", +"+. c #8CA545", +"@. c #329829", +"#. c #65B853", +"$. c #81C864", +"%. c #96D476", +"&. c #A0D883", +"*. c #87CC67", +"=. c #6EBE53", +"-. c #4EAA3A", +";. c #1D8D12", +">. c #2B994F", +",. c #6BC0D0", +"'. c #9CD9FE", +"). c #96D0FA", +"!. c #5AA2EC", +"~. c #2377DB", +"{. c #FEC729", +"]. c #FECB50", +"^. c #FFCD63", +"/. c #FFCD68", +"(. c #FECB67", +"_. c #D5BC55", +":. c #54A237", +"<. c #91CD81", +"[. c #A6D698", +"}. c #A9D79E", +"|. c #9BD28B", +"1. c #78BF60", +"2. c #35A04D", +"3. c #59C3CD", +"4. c #6DD4F6", +"5. c #73DAFF", +"6. c #71D7FF", +"7. c #70D4FF", +"8. c #6CCCFE", +"9. c #5FB4F6", +"0. c #2B7BDD", +"a. c #FFDB3F", +"b. c #FEDF3F", +"c. c #FFDD44", +"d. c #FFDA45", +"e. c #FED644", +"f. c #FFD443", +"g. c #F2CA3B", +"h. c #68A52A", +"i. c #A6D49E", +"j. c #B4D9AC", +"k. c #67B35C", +"l. c #25B190", +"m. c #3ECBFF", +"n. c #49D8FF", +"o. c #4DE0FE", +"p. c #4FE4FF", +"q. c #4FE1FF", +"r. c #4ADAFF", +"s. c #47CEFE", +"t. c #43C2FF", +"u. c #37A8F6", +"v. c #208CE3", +"w. c #FFD946", +"x. c #FFEE61", +"y. c #FFF554", +"z. c #FFF43C", +"A. c #FFF030", +"B. c #FEED30", +"C. c #FFEA4A", +"D. c #FFE74F", +"E. c #9FC22F", +"F. c #A2B727", +"G. c #9CBC4B", +"H. c #3DE2CD", +"I. c #5DE9E5", +"J. c #57ECFF", +"K. c #45F3FF", +"L. c #40F6FF", +"M. c #3BF4FF", +"N. c #49ECFF", +"O. c #51E1FF", +"P. c #4AD8FE", +"Q. c #39CDFF", +"R. c #21ACEF", +"S. c #FFD43D", +"T. c #FFE96D", +"U. c #FFF472", +"V. c #FFFC76", +"W. c #FFFE72", +"X. c #FFFE8C", +"Y. c #FEF668", +"Z. c #FFEF64", +"`. c #EBDF3B", +" + c #E5C91A", +".+ c #A7BA4B", +"++ c #31D3C7", +"@+ c #6DEAE0", +"#+ c #71F6FF", +"$+ c #8CFCFF", +"%+ c #9BFDFE", +"&+ c #A4FDFF", +"*+ c #71F7FF", +"=+ c #61EBFE", +"-+ c #4BDAFF", +";+ c #28C0FF", +">+ c #1D9FEB", +",+ c #FFCA29", +"'+ c #FFDD45", +")+ c #FFED71", +"!+ c #FFF37B", +"~+ c #FFF9BC", +"{+ c #FFF065", +"]+ c #FFEE81", +"^+ c #FFE857", +"/+ c #E9D426", +"(+ c #E3C119", +"_+ c #A5B14A", +":+ c #1EC0C7", +"<+ c #43D6E0", +"[+ c #75EAFF", +"}+ c #83F2FF", +"|+ c #ABF5FE", +"1+ c #76EEFD", +"2+ c #82E8FD", +"3+ c #5EDEFE", +"4+ c #2FC6FF", +"5+ c #24B2FE", +"6+ c #1989E1", +"7+ c #FFBF23", +"8+ c #FFCE28", +"9+ c #FFDC47", +"0+ c #FFE469", +"a+ c #FFE586", +"b+ c #FFDD7A", +"c+ c #FFD86B", +"d+ c #FFCE38", +"e+ c #E7C620", +"f+ c #E2B716", +"g+ c #A3A347", +"h+ c #16ACC7", +"i+ c #26BDE0", +"j+ c #45CFFF", +"k+ c #73DDFE", +"l+ c #6FD9FC", +"m+ c #8CDAFA", +"n+ c #6ECCF8", +"o+ c #39B9F8", +"p+ c #23B1FD", +"q+ c #1C98F5", +"r+ c #1266CD", +"s+ c #FFB322", +"t+ c #FEC73D", +"u+ c #FFD255", +"v+ c #FFD96B", +"w+ c #FFE38D", +"x+ c #FFD463", +"y+ c #FFC843", +"z+ c #E6B526", +"A+ c #E0A713", +"B+ c #9E8C3F", +"C+ c #1086B9", +"D+ c #31ABDE", +"E+ c #4EC1FF", +"F+ c #69CFFE", +"G+ c #80D7FE", +"H+ c #84D8FE", +"I+ c #63CAFE", +"J+ c #3FB1FB", +"K+ c #2890EC", +"L+ c #1369D8", +"M+ c #0A3EB6", +"N+ c #F9AE33", +"O+ c #FFCB5B", +"P+ c #FED56F", +"Q+ c #FFDB7C", +"R+ c #FFE396", +"S+ c #FFDD82", +"T+ c #FED56E", +"U+ c #E5B736", +"V+ c #D99E17", +"W+ c #936E2A", +"X+ c #1A65A3", +"Y+ c #4C9ED1", +"Z+ c #69BDF8", +"`+ c #77C9FB", +" @ c #8CD4FD", +".@ c #85D0FC", +"+@ c #69BEF7", +"@@ c #54A8EF", +"#@ c #3983E1", +"$@ c #174AC3", +"%@ c #031894", +"&@ c #E4A13A", +"*@ c #FFD275", +"=@ c #FFE29A", +"-@ c #FEE4A3", +";@ c #FFDF94", +">@ c #FFDB86", +",@ c #FFC056", +"'@ c #BC8C24", +")@ c #76520A", +"!@ c #2D5CAA", +"~@ c #71A4E6", +"{@ c #92C5F0", +"]@ c #9CCAF1", +"^@ c #90C3EF", +"/@ c #82B8EC", +"(@ c #5586D9", +"_@ c #254AAB", +":@ c #06166C", +"<@ c #B77523", +"[@ c #FFCA80", +"}@ c #FFEABD", +"|@ c #FFDB9C", +"1@ c #DE993D", +"2@ c #112489", +"3@ c #758AD5", +"4@ c #C0D4F0", +"5@ c #A4BAE8", +"6@ c #3D51B4", +"7@ c #0A1658", +"8@ c #EC9B50", +"9@ c #8E4500", +"0@ c #454CAF", +"a@ c #070A69", +" ", +" . + @ ", +" # $ % & * = - ", +" ; > , ' ) ! ~ { ] ^ ", +" / ( _ : < [ } | 1 2 3 4 ", +" 5 6 7 8 9 0 a b c d e f ", +" g h i j k l m n o p q r ", +" s t u v w x y z A B C D ", +" E F G H I J K L M q N D ", +" O P Q R S T U V W X Y Z ` . ", +" ..+.@.#.$.%.&.*.=.-.;.>.,.'.).!.~. ", +" {.].^./.(._.:.<.[.}.|.1.2.3.4.5.6.7.8.9.0. ", +" a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v. ", +" w.x.y.z.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R. ", +" S.T.U.V.W.X.Y.Z.`. +.+++@+#+$+%+&+*+=+-+;+>+ ", +" ,+'+)+!+~+{+]+^+/+(+_+:+<+[+}+|+1+2+3+4+5+6+ ", +" 7+8+9+0+a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+ ", +" s+t+u+v+w+b+x+y+z+A+B+C+D+E+F+G+H+I+J+K+L+M+ ", +" N+O+P+Q+R+S+T+O+U+V+W+X+Y+Z+`+ @.@+@@@#@$@%@ ", +" &@*@=@-@;@>@,@'@)@ !@~@{@]@^@/@(@_@:@ ", +" <@[@}@|@1@ 2@3@4@5@6@7@ ", +" 8@9@ 0@a@ ", +" ", +" "}; diff --git a/icons/document-switch-mode-16.xpm b/icons/document-switch-mode-16.xpm new file mode 100644 index 0000000..924a29a --- /dev/null +++ b/icons/document-switch-mode-16.xpm @@ -0,0 +1,60 @@ +/* XPM */ +static const char * document_switch_mode_16_xpm[] = { +"16 16 41 1", +" c None", +". c #909090", +"+ c #8D8D8D", +"@ c #9B9B9B", +"# c #9A9A9A", +"$ c #999999", +"% c #989898", +"& c #979797", +"* c #969696", +"= c #A2A2A2", +"- c #9F9F9F", +"; c #8F8F8F", +"> c #A3A3A3", +", c #A9A9A9", +"' c #A8A8A8", +") c #A6A6A6", +"! c #9C9C9C", +"~ c #929292", +"{ c #7B7B7B", +"] c #A4A4A4", +"^ c #AAAAAA", +"/ c #9D9D9D", +"( c #8A8A8A", +"_ c #888888", +": c #898989", +"< c #8C8C8C", +"[ c #848484", +"} c #828282", +"| c #A0A0A0", +"1 c #808080", +"2 c #727272", +"3 c #747474", +"4 c #757575", +"5 c #7C7C7C", +"6 c #7A7A7A", +"7 c #939393", +"8 c #838383", +"9 c #858585", +"0 c #878787", +"a c #818181", +"b c #737373", +" ", +" ", +" ", +" .+ ", +" @#$%&*=-; ", +" >,,'')-!@~{", +" ]^,/~(_:<: ", +" @ [_ ", +" })|1 2234 5 ", +"6>=7_:(+;.+ ", +"}$;}}890::0 ", +" 35ab ", +" b ", +" ", +" ", +" "}; diff --git a/icons/document-switch-mode-24.xpm b/icons/document-switch-mode-24.xpm new file mode 100644 index 0000000..cb68653 --- /dev/null +++ b/icons/document-switch-mode-24.xpm @@ -0,0 +1,80 @@ +/* XPM */ +static const char * document_switch_mode_24_xpm[] = { +"24 24 53 1", +" c None", +". c #9A9A9A", +"+ c #A2A2A2", +"@ c #A1A1A1", +"# c #767676", +"$ c #A6A6A6", +"% c #797979", +"& c #A9A9A9", +"* c #A8A8A8", +"= c #A7A7A7", +"- c #A5A5A5", +"; c #A4A4A4", +"> c #A3A3A3", +", c #7D7D7D", +"' c #AFAFAF", +") c #AEAEAE", +"! c #ADADAD", +"~ c #ACACAC", +"{ c #ABABAB", +"] c #AAAAAA", +"^ c #A0A0A0", +"/ c #9C9C9C", +"( c #999999", +"_ c #969696", +": c #919191", +"< c #6E6E6E", +"[ c #9D9D9D", +"} c #929292", +"| c #898989", +"1 c #858585", +"2 c #878787", +"3 c #888888", +"4 c #8A8A8A", +"5 c #8B8B8B", +"6 c #5C5C5C", +"7 c #909090", +"8 c #8D8D8D", +"9 c #7E7E7E", +"0 c #747474", +"a c #757575", +"b c #8E8E8E", +"c c #828282", +"d c #7A7A7A", +"e c #868686", +"f c #8C8C8C", +"g c #787878", +"h c #7B7B7B", +"i c #8F8F8F", +"j c #686868", +"k c #9E9E9E", +"l c #848484", +"m c #777777", +"n c #7C7C7C", +" ", +" ", +" ", +" ", +" . ", +" +@# ", +" +$@% ", +" +&*=$--;>>=$-@, ", +" =')!~{{]&;^/(_:<", +" =')!~*[}|12345|6", +" + 47789000a#3582 ", +" #=* |b1 ", +" %$]; 5c ", +" d;$$+41e23|4f84 g ", +"h+>>(2e3|458bi7b ", +"jk>}le23|5f8b7:b ", +" fl11#mg%dhnn9h ", +" ,el ", +" nl ", +" # ", +" ", +" ", +" ", +" "}; diff --git a/sdk/CMakeLists.txt b/sdk/CMakeLists.txt new file mode 100644 index 0000000..4c238e8 --- /dev/null +++ b/sdk/CMakeLists.txt @@ -0,0 +1,27 @@ +# This file is part of EPOCH. +# File: CMakeLists.txt +# Author: Florent Teichteil-Königsbuch +# Contact: florent.teichteil@onera.fr +# +# EPOCH 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. +# +# EPOCH 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 EPOCH. If not, see . + +MESSAGE (STATUS "COMPILES the Software Development Kit (additional provided dependencies)") +IF (BUILD_GUI) + INCLUDE (${wxWidgets_USE_FILE}) + ADD_SUBDIRECTORY (wxscintilla) + ADD_SUBDIRECTORY (wxshapeframework) +ENDIF (BUILD_GUI) + +ADD_SUBDIRECTORY(buddy-2.4) + diff --git a/sdk/boost/numeric/bindings/addressing_index.hpp b/sdk/boost/numeric/bindings/addressing_index.hpp new file mode 100644 index 0000000..5c4256b --- /dev/null +++ b/sdk/boost/numeric/bindings/addressing_index.hpp @@ -0,0 +1,74 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_INDEX_HPP +#define BOOST_NUMERIC_BINDINGS_INDEX_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct addressing_index_minor { + typedef typename mpl::if_< + is_column_major< T >, + tag::addressing_index<1>, + tag::addressing_index< + mpl::max< tag::matrix, rank< T > >::type::value + > + >::type type; +}; + +template< typename T > +struct addressing_index_major { + typedef typename mpl::if_< + is_column_major< T >, + tag::addressing_index< + mpl::max< tag::matrix, rank< T > >::type::value + >, + tag::addressing_index<1> + >::type type; +}; + + +template< typename AddressingIndex, typename TransTag > +struct addressing_index_trans { + typedef AddressingIndex type; +}; + +template<> +struct addressing_index_trans< tag::addressing_index<1>, tag::transpose > { + typedef tag::addressing_index<2> type; +}; + +template<> +struct addressing_index_trans< tag::addressing_index<1>, tag::conjugate > { + typedef tag::addressing_index<2> type; +}; + +template<> +struct addressing_index_trans< tag::addressing_index<2>, tag::transpose > { + typedef tag::addressing_index<1> type; +}; + +template<> +struct addressing_index_trans< tag::addressing_index<2>, tag::conjugate > { + typedef tag::addressing_index<1> type; +}; + + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/at.hpp b/sdk/boost/numeric/bindings/at.hpp new file mode 100644 index 0000000..7b1eda5 --- /dev/null +++ b/sdk/boost/numeric/bindings/at.hpp @@ -0,0 +1,71 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_AT_HPP +#define BOOST_NUMERIC_BINDINGS_AT_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Enable = void > +struct at_impl { + + typedef typename bindings::value_type::type& result_type; + + // TODO implement other array structures such as triangular, band, etc. + static result_type invoke( T& t, const std::ptrdiff_t i1, std::ptrdiff_t i2 ) { + return t( i1, i2 ); + } + +}; + +template< typename T > +struct at_impl< T, typename boost::enable_if< bindings::has_linear_array >::type > { + + typedef typename bindings::value_type::type& result_type; + + static result_type invoke( T& t, const std::ptrdiff_t i1 ) { + return *( bindings::begin_value(t) + offset(t,i1) ); + } + + static result_type invoke( T& t, const std::ptrdiff_t i1, std::ptrdiff_t i2 ) { + return *( bindings::begin_value(t) + offset(t,i1,i2) ); + } + +}; + +} + +namespace result_of { + +template< typename T > +struct at { + typedef typename detail::at_impl::result_type type; +}; + +} + +template< typename T > +typename result_of::at::type at( T& t, const std::ptrdiff_t i1 ) { + return detail::at_impl::invoke( t, i1 ); +} + +template< typename T > +typename result_of::at::type at( T& t, const std::ptrdiff_t i1, const std::ptrdiff_t i2 ) { + return detail::at_impl::invoke( t, i1, i2 ); +} + +} // bindings +} // numeric +} // boost + +#endif diff --git a/sdk/boost/numeric/bindings/bandwidth.hpp b/sdk/boost/numeric/bindings/bandwidth.hpp new file mode 100644 index 0000000..c489c66 --- /dev/null +++ b/sdk/boost/numeric/bindings/bandwidth.hpp @@ -0,0 +1,167 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BANDWIDTH_HPP +#define BOOST_NUMERIC_BINDINGS_BANDWIDTH_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename AddressingIndex, typename Enable = void > +struct bandwidth_impl { + + typedef typename tag::bandwidth_type< AddressingIndex::value > key_type; + typedef typename result_of_get< T, key_type >::type result_type; + + static result_type invoke( const T& t ) { + return get< key_type >( t ); + } + +}; + +template< typename T > +struct bandwidth_impl< T, tag::lower >: + bandwidth_impl< T, tag::addressing_index<1> > {}; + + +template< typename T > +struct bandwidth_impl< T, tag::upper >: + bandwidth_impl< T, tag::addressing_index<2> > {}; + + +template< typename T, int N > +struct bandwidth_impl< T, tag::addressing_index, + typename boost::enable_if< typename mpl::and_< + mpl::greater< tag::addressing_index, rank >, + is_same_at< T, tag::bandwidth_type<1>, std::ptrdiff_t > + >::type >::type > { + + typedef std::ptrdiff_t result_type; + + static result_type invoke( const T& t ) { + return std::min< std::ptrdiff_t >( bandwidth_impl >::invoke(t), 1 ); + } + +}; + +template< typename T, int N > +struct bandwidth_impl< T, tag::addressing_index, + typename boost::enable_if< typename mpl::and_< + mpl::greater< tag::addressing_index, rank >, + mpl::not_< is_same_at< T, tag::bandwidth_type<1>, std::ptrdiff_t > > + >::type >::type > { + + typedef typename mpl::min< + typename detail::property_at< T, tag::bandwidth_type<1> >::type, + mpl::int_<1> + >::type result_type; + + static result_type invoke( const T& t ) { + return result_type(); + } + +}; + +} // namespace detail + + +namespace result_of { + +template< typename T, typename Tag = tag::addressing_index<1> > +struct bandwidth { + BOOST_STATIC_ASSERT( (is_tag::value) ); + typedef typename detail::bandwidth_impl< T, Tag >::result_type type; +}; + +} // namespace result_of + +// +// Overloads for free template functions bandwidth( x, tag ), +// +template< typename T, typename Tag > +inline typename result_of::bandwidth< const T, Tag >::type +bandwidth( const T& t, Tag ) { + return detail::bandwidth_impl< const T, Tag >::invoke( t ); +} + +// Overloads for free template function bandwidth( x ) +// Valid for types with rank <= 1 (scalars, vectors) +// In theory, we could provide overloads for matrices here, too, +// if their minimal_rank is at most 1. + +// template< typename T > +// typename boost::enable_if< mpl::less< rank, mpl::int_<2> >, +// typename result_of::bandwidth< const T >::type >::type +// bandwidth( const T& t ) { +// return detail::bandwidth_impl< const T, tag::addressing_index<1> >::invoke( t ); +// } + +#define GENERATE_BANDWIDTH_INDEX( z, which, unused ) \ +GENERATE_FUNCTIONS( bandwidth, which, tag::addressing_index ) + +BOOST_PP_REPEAT_FROM_TO(1,3,GENERATE_BANDWIDTH_INDEX,~) + +GENERATE_FUNCTIONS( bandwidth, _left, tag::addressing_index<1> ) +GENERATE_FUNCTIONS( bandwidth, _right, tag::addressing_index<2> ) +GENERATE_FUNCTIONS( bandwidth, _lower, tag::addressing_index<1> ) +GENERATE_FUNCTIONS( bandwidth, _upper, tag::addressing_index<2> ) +GENERATE_FUNCTIONS( bandwidth, _major, typename addressing_index_major::type ) +GENERATE_FUNCTIONS( bandwidth, _minor, typename addressing_index_minor::type ) + +// +// Overloads for free template functions bandwidth_row( x, tag ), +// Here, tag is assumed to be either one of +// tag::transpose, tag::no_transpose, or tag::conjugate +// +namespace result_of { + +template< typename T, typename TransTag > +struct bandwidth_lower_op { + typedef typename bandwidth< + T, + typename addressing_index_trans< tag::addressing_index<1>, TransTag >::type + >::type type; +}; + +template< typename T, typename TransTag > +struct bandwidth_upper_op { + typedef typename bandwidth< T, + typename addressing_index_trans< tag::addressing_index<2>, TransTag >::type >::type type; +}; + +} // namespace result_of + +template< typename T, typename Tag > +inline typename result_of::bandwidth_lower_op< const T, Tag >::type +bandwidth_lower_op( const T& t, Tag ) { + return bindings::bandwidth( t, typename addressing_index_trans< tag::addressing_index<1>, Tag >::type() ); +} + +template< typename T, typename Tag > +inline typename result_of::bandwidth_upper_op< const T, Tag >::type +bandwidth_upper_op( const T& t, Tag ) { + return bindings::bandwidth( t, typename addressing_index_trans< tag::addressing_index<2>, Tag >::type() ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/begin.hpp b/sdk/boost/numeric/bindings/begin.hpp new file mode 100644 index 0000000..8beda8d --- /dev/null +++ b/sdk/boost/numeric/bindings/begin.hpp @@ -0,0 +1,145 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BEGIN_HPP +#define BOOST_NUMERIC_BINDINGS_BEGIN_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +namespace detail { + +template< typename T, typename Tag > +struct begin_impl {}; + +template< typename T > +struct begin_impl< T, tag::value > { + typedef typename bindings::value_type< T>::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::begin_value( t ); + } +}; + +template< typename T, int Dimension > +struct begin_impl > { + + typedef tag::addressing_index tag_type; + + typedef linear_iterator< + typename bindings::value_type< T>::type, + typename result_of::stride< T, tag_type >::type + > result_type; + + static result_type invoke( T& t ) { + return result_type( adaptor_access::begin_value( t ), bindings::stride(t, tag_type() ) ); + } +}; + +template< typename T > +struct begin_impl< T, tag::index_major > { + typedef typename detail::property_at< T, tag::index_type >::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::begin_index_major( t ); + } +}; + +template< typename T > +struct begin_impl< T, tag::compressed_index_major > { + typedef typename detail::property_at< T, tag::index_type >::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::begin_compressed_index_major( t ); + } +}; + +template< typename T > +struct begin_impl< T, tag::index_minor > { + typedef typename detail::property_at< T, tag::index_type >::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::begin_index_minor( t ); + } +}; + +} // namespace detail + +namespace result_of { + +template< typename T, typename Tag = tag::addressing_index<1> > +struct begin { + BOOST_STATIC_ASSERT( (is_tag::value) ); + typedef typename detail::begin_impl::result_type type; +}; + +} // namespace result_of + +// +// Free Functions +// + +// +// Overloads like begin( t, tag ) +// +template< typename T, typename Tag > +inline typename result_of::begin::type +begin( T& t, Tag ) { + return detail::begin_impl::invoke( t ); +} + +template< typename T, typename Tag > +inline typename result_of::begin::type +begin( const T& t, Tag ) { + return detail::begin_impl::invoke( t ); +} + +// Overloads for types with rank <= 1 (scalars, vectors) +// In theory, we could provide overloads for matrices here, too, +// if their minimal_rank is at most 1. + +template< typename T > +typename boost::enable_if< mpl::less< rank, mpl::int_<2> >, + typename result_of::begin< T >::type >::type +begin( T& t ) { + return detail::begin_impl< T, tag::addressing_index<1> >::invoke( t ); +} + +template< typename T > +typename boost::enable_if< mpl::less< rank, mpl::int_<2> >, + typename result_of::begin< const T >::type >::type +begin( const T& t ) { + return detail::begin_impl< const T, tag::addressing_index<1> >::invoke( t ); +} + +#define GENERATE_BEGIN_INDEX( z, which, unused ) \ +GENERATE_FUNCTIONS( begin, which, tag::addressing_index ) + +BOOST_PP_REPEAT_FROM_TO(1,3,GENERATE_BEGIN_INDEX,~) +GENERATE_FUNCTIONS( begin, _value, tag::value ) +GENERATE_FUNCTIONS( begin, _row, tag::addressing_index<1> ) +GENERATE_FUNCTIONS( begin, _column, tag::addressing_index<2> ) + +GENERATE_FUNCTIONS( begin, _index_major, tag::index_major ) +GENERATE_FUNCTIONS( begin, _compressed_index_major, tag::compressed_index_major ) +GENERATE_FUNCTIONS( begin, _index_minor, tag::index_minor ) + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas.hpp b/sdk/boost/numeric/bindings/blas.hpp new file mode 100644 index 0000000..71f7eb7 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas.hpp @@ -0,0 +1,17 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_HPP + +#include +#include +#include + +#endif + diff --git a/sdk/boost/numeric/bindings/blas/detail/blas.h b/sdk/boost/numeric/bindings/blas/detail/blas.h new file mode 100644 index 0000000..54bd711 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/blas.h @@ -0,0 +1,574 @@ +// +// Copyright (c) 2003--2009 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_H +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_H + +#include + +extern "C" { + +// +// BLAS level1 routines +// + +// Value-type variants of asum +float BLAS_SASUM( const fortran_int_t* n, const float* x, + const fortran_int_t* incx ); +double BLAS_DASUM( const fortran_int_t* n, const double* x, + const fortran_int_t* incx ); +float BLAS_SCASUM( const fortran_int_t* n, const void* x, + const fortran_int_t* incx ); +double BLAS_DZASUM( const fortran_int_t* n, const void* x, + const fortran_int_t* incx ); + +// Value-type variants of axpy +void BLAS_SAXPY( const fortran_int_t* n, const float* a, const float* x, + const fortran_int_t* incx, float* y, const fortran_int_t* incy ); +void BLAS_DAXPY( const fortran_int_t* n, const double* a, const double* x, + const fortran_int_t* incx, double* y, const fortran_int_t* incy ); +void BLAS_CAXPY( const fortran_int_t* n, const void* a, const void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy ); +void BLAS_ZAXPY( const fortran_int_t* n, const void* a, const void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy ); + +// Value-type variants of copy +void BLAS_SCOPY( const fortran_int_t* n, const float* x, + const fortran_int_t* incx, float* y, const fortran_int_t* incy ); +void BLAS_DCOPY( const fortran_int_t* n, const double* x, + const fortran_int_t* incx, double* y, const fortran_int_t* incy ); +void BLAS_CCOPY( const fortran_int_t* n, const void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy ); +void BLAS_ZCOPY( const fortran_int_t* n, const void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy ); + +// Value-type variants of dot +float BLAS_SDOT( const fortran_int_t* n, const float* x, + const fortran_int_t* incx, const float* y, const fortran_int_t* incy ); +double BLAS_DDOT( const fortran_int_t* n, const double* x, + const fortran_int_t* incx, const double* y, + const fortran_int_t* incy ); +std::complex BLAS_CDOTU( const fortran_int_t* n, const void* x, + const fortran_int_t* incx, const void* y, const fortran_int_t* incy ); +std::complex BLAS_ZDOTU( const fortran_int_t* n, const void* x, + const fortran_int_t* incx, const void* y, const fortran_int_t* incy ); + +// Value-type variants of dotc +std::complex BLAS_CDOTC( const fortran_int_t* n, const void* x, + const fortran_int_t* incx, const void* y, const fortran_int_t* incy ); +std::complex BLAS_ZDOTC( const fortran_int_t* n, const void* x, + const fortran_int_t* incx, const void* y, const fortran_int_t* incy ); + +// Value-type variants of iamax +fortran_int_t BLAS_ISAMAX( const fortran_int_t* n, const float* x, + const fortran_int_t* incx ); +fortran_int_t BLAS_IDAMAX( const fortran_int_t* n, const double* x, + const fortran_int_t* incx ); +fortran_int_t BLAS_ICAMAX( const fortran_int_t* n, const void* x, + const fortran_int_t* incx ); +fortran_int_t BLAS_IZAMAX( const fortran_int_t* n, const void* x, + const fortran_int_t* incx ); + +// Value-type variants of nrm2 +float BLAS_SNRM2( const fortran_int_t* n, const float* x, + const fortran_int_t* incx ); +double BLAS_DNRM2( const fortran_int_t* n, const double* x, + const fortran_int_t* incx ); +float BLAS_SCNRM2( const fortran_int_t* n, const void* x, + const fortran_int_t* incx ); +double BLAS_DZNRM2( const fortran_int_t* n, const void* x, + const fortran_int_t* incx ); + +// Value-type variants of prec_dot +double BLAS_DSDOT( const fortran_int_t* n, const float* x, + const fortran_int_t* incx, const float* y, const fortran_int_t* incy ); + +// Value-type variants of rot +void BLAS_SROT( const fortran_int_t* n, float* x, const fortran_int_t* incx, + float* y, const fortran_int_t* incy, const float* c, const float* s ); +void BLAS_DROT( const fortran_int_t* n, double* x, const fortran_int_t* incx, + double* y, const fortran_int_t* incy, const double* c, + const double* s ); +void BLAS_CSROT( const fortran_int_t* n, void* x, const fortran_int_t* incx, + void* y, const fortran_int_t* incy, const float* c, const float* s ); +void BLAS_ZDROT( const fortran_int_t* n, void* x, const fortran_int_t* incx, + void* y, const fortran_int_t* incy, const double* c, const double* s ); + +// Value-type variants of rotg +void BLAS_SROTG( float* a, float* b, float* c, float* s ); +void BLAS_DROTG( double* a, double* b, double* c, double* s ); +void BLAS_CROTG( void* a, void* b, float* c, void* s ); +void BLAS_ZROTG( void* a, void* b, double* c, void* s ); + +// Value-type variants of rotm +void BLAS_SROTM( const fortran_int_t* n, float* x, const fortran_int_t* incx, + float* y, const fortran_int_t* incy, float* param ); +void BLAS_DROTM( const fortran_int_t* n, double* x, const fortran_int_t* incx, + double* y, const fortran_int_t* incy, double* param ); + +// Value-type variants of rotmg +void BLAS_SROTMG( float* d1, float* d2, float* x1, const float* y1, + float* sparam ); +void BLAS_DROTMG( double* d1, double* d2, double* x1, const double* y1, + double* dparam ); + +// Value-type variants of scal +void BLAS_SSCAL( const fortran_int_t* n, const float* a, float* x, + const fortran_int_t* incx ); +void BLAS_DSCAL( const fortran_int_t* n, const double* a, double* x, + const fortran_int_t* incx ); +void BLAS_CSSCAL( const fortran_int_t* n, const float* a, void* x, + const fortran_int_t* incx ); +void BLAS_ZDSCAL( const fortran_int_t* n, const double* a, void* x, + const fortran_int_t* incx ); +void BLAS_CSCAL( const fortran_int_t* n, const void* a, void* x, + const fortran_int_t* incx ); +void BLAS_ZSCAL( const fortran_int_t* n, const void* a, void* x, + const fortran_int_t* incx ); + +// Value-type variants of swap +void BLAS_SSWAP( const fortran_int_t* n, float* x, const fortran_int_t* incx, + float* y, const fortran_int_t* incy ); +void BLAS_DSWAP( const fortran_int_t* n, double* x, const fortran_int_t* incx, + double* y, const fortran_int_t* incy ); +void BLAS_CSWAP( const fortran_int_t* n, void* x, const fortran_int_t* incx, + void* y, const fortran_int_t* incy ); +void BLAS_ZSWAP( const fortran_int_t* n, void* x, const fortran_int_t* incx, + void* y, const fortran_int_t* incy ); + +// +// BLAS level2 routines +// + +// Value-type variants of gbmv +void BLAS_SGBMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const float* alpha, const float* a, + const fortran_int_t* lda, const float* x, const fortran_int_t* incx, + const float* beta, float* y, const fortran_int_t* incy ); +void BLAS_DGBMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const double* alpha, const double* a, + const fortran_int_t* lda, const double* x, const fortran_int_t* incx, + const double* beta, double* y, const fortran_int_t* incy ); +void BLAS_CGBMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const void* alpha, const void* a, + const fortran_int_t* lda, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); +void BLAS_ZGBMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const void* alpha, const void* a, + const fortran_int_t* lda, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); + +// Value-type variants of gemv +void BLAS_SGEMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const float* alpha, const float* a, + const fortran_int_t* lda, const float* x, const fortran_int_t* incx, + const float* beta, float* y, const fortran_int_t* incy ); +void BLAS_DGEMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const double* alpha, const double* a, + const fortran_int_t* lda, const double* x, const fortran_int_t* incx, + const double* beta, double* y, const fortran_int_t* incy ); +void BLAS_CGEMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const void* alpha, const void* a, + const fortran_int_t* lda, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); +void BLAS_ZGEMV( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const void* alpha, const void* a, + const fortran_int_t* lda, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); + +// Value-type variants of ger +void BLAS_SGER( const fortran_int_t* m, const fortran_int_t* n, + const float* alpha, const float* x, const fortran_int_t* incx, + const float* y, const fortran_int_t* incy, float* a, + const fortran_int_t* lda ); +void BLAS_DGER( const fortran_int_t* m, const fortran_int_t* n, + const double* alpha, const double* x, const fortran_int_t* incx, + const double* y, const fortran_int_t* incy, double* a, + const fortran_int_t* lda ); + +// Value-type variants of gerc +void BLAS_CGERC( const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* x, const fortran_int_t* incx, + const void* y, const fortran_int_t* incy, void* a, + const fortran_int_t* lda ); +void BLAS_ZGERC( const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* x, const fortran_int_t* incx, + const void* y, const fortran_int_t* incy, void* a, + const fortran_int_t* lda ); + +// Value-type variants of geru +void BLAS_CGERU( const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* x, const fortran_int_t* incx, + const void* y, const fortran_int_t* incy, void* a, + const fortran_int_t* lda ); +void BLAS_ZGERU( const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* x, const fortran_int_t* incx, + const void* y, const fortran_int_t* incy, void* a, + const fortran_int_t* lda ); + +// Value-type variants of hbmv +void BLAS_CHBMV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); +void BLAS_ZHBMV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); + +// Value-type variants of hemv +void BLAS_CHEMV( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* a, const fortran_int_t* lda, const void* x, + const fortran_int_t* incx, const void* beta, void* y, + const fortran_int_t* incy ); +void BLAS_ZHEMV( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* a, const fortran_int_t* lda, const void* x, + const fortran_int_t* incx, const void* beta, void* y, + const fortran_int_t* incy ); + +// Value-type variants of her +void BLAS_CHER( const char* uplo, const fortran_int_t* n, const float* alpha, + const void* x, const fortran_int_t* incx, void* a, + const fortran_int_t* lda ); +void BLAS_ZHER( const char* uplo, const fortran_int_t* n, const double* alpha, + const void* x, const fortran_int_t* incx, void* a, + const fortran_int_t* lda ); + +// Value-type variants of her2 +void BLAS_CHER2( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* x, const fortran_int_t* incx, const void* y, + const fortran_int_t* incy, void* a, const fortran_int_t* lda ); +void BLAS_ZHER2( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* x, const fortran_int_t* incx, const void* y, + const fortran_int_t* incy, void* a, const fortran_int_t* lda ); + +// Value-type variants of hpmv +void BLAS_CHPMV( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* ap, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); +void BLAS_ZHPMV( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* ap, const void* x, const fortran_int_t* incx, + const void* beta, void* y, const fortran_int_t* incy ); + +// Value-type variants of hpr +void BLAS_CHPR( const char* uplo, const fortran_int_t* n, const float* alpha, + const void* x, const fortran_int_t* incx, void* ap ); +void BLAS_ZHPR( const char* uplo, const fortran_int_t* n, const double* alpha, + const void* x, const fortran_int_t* incx, void* ap ); + +// Value-type variants of hpr2 +void BLAS_CHPR2( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* x, const fortran_int_t* incx, const void* y, + const fortran_int_t* incy, void* ap ); +void BLAS_ZHPR2( const char* uplo, const fortran_int_t* n, const void* alpha, + const void* x, const fortran_int_t* incx, const void* y, + const fortran_int_t* incy, void* ap ); + +// Value-type variants of sbmv +void BLAS_SSBMV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* k, const float* alpha, const float* a, + const fortran_int_t* lda, const float* x, const fortran_int_t* incx, + const float* beta, float* y, const fortran_int_t* incy ); +void BLAS_DSBMV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* k, const double* alpha, const double* a, + const fortran_int_t* lda, const double* x, const fortran_int_t* incx, + const double* beta, double* y, const fortran_int_t* incy ); + +// Value-type variants of spmv +void BLAS_SSPMV( const char* uplo, const fortran_int_t* n, const float* alpha, + const float* ap, const float* x, const fortran_int_t* incx, + const float* beta, float* y, const fortran_int_t* incy ); +void BLAS_DSPMV( const char* uplo, const fortran_int_t* n, + const double* alpha, const double* ap, const double* x, + const fortran_int_t* incx, const double* beta, double* y, + const fortran_int_t* incy ); + +// Value-type variants of spr +void BLAS_SSPR( const char* uplo, const fortran_int_t* n, const float* alpha, + const float* x, const fortran_int_t* incx, float* ap ); +void BLAS_DSPR( const char* uplo, const fortran_int_t* n, const double* alpha, + const double* x, const fortran_int_t* incx, double* ap ); + +// Value-type variants of spr2 +void BLAS_SSPR2( const char* uplo, const fortran_int_t* n, const float* alpha, + const float* x, const fortran_int_t* incx, const float* y, + const fortran_int_t* incy, float* ap ); +void BLAS_DSPR2( const char* uplo, const fortran_int_t* n, + const double* alpha, const double* x, const fortran_int_t* incx, + const double* y, const fortran_int_t* incy, double* ap ); + +// Value-type variants of symv +void BLAS_SSYMV( const char* uplo, const fortran_int_t* n, const float* alpha, + const float* a, const fortran_int_t* lda, const float* x, + const fortran_int_t* incx, const float* beta, float* y, + const fortran_int_t* incy ); +void BLAS_DSYMV( const char* uplo, const fortran_int_t* n, + const double* alpha, const double* a, const fortran_int_t* lda, + const double* x, const fortran_int_t* incx, const double* beta, + double* y, const fortran_int_t* incy ); + +// Value-type variants of syr +void BLAS_SSYR( const char* uplo, const fortran_int_t* n, const float* alpha, + const float* x, const fortran_int_t* incx, float* a, + const fortran_int_t* lda ); +void BLAS_DSYR( const char* uplo, const fortran_int_t* n, const double* alpha, + const double* x, const fortran_int_t* incx, double* a, + const fortran_int_t* lda ); + +// Value-type variants of syr2 +void BLAS_SSYR2( const char* uplo, const fortran_int_t* n, const float* alpha, + const float* x, const fortran_int_t* incx, const float* y, + const fortran_int_t* incy, float* a, const fortran_int_t* lda ); +void BLAS_DSYR2( const char* uplo, const fortran_int_t* n, + const double* alpha, const double* x, const fortran_int_t* incx, + const double* y, const fortran_int_t* incy, double* a, + const fortran_int_t* lda ); + +// Value-type variants of tbmv +void BLAS_STBMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const float* a, + const fortran_int_t* lda, float* x, const fortran_int_t* incx ); +void BLAS_DTBMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const double* a, + const fortran_int_t* lda, double* x, const fortran_int_t* incx ); +void BLAS_CTBMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const void* a, + const fortran_int_t* lda, void* x, const fortran_int_t* incx ); +void BLAS_ZTBMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const void* a, + const fortran_int_t* lda, void* x, const fortran_int_t* incx ); + +// Value-type variants of tbsv +void BLAS_STBSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const float* a, + const fortran_int_t* lda, float* x, const fortran_int_t* incx ); +void BLAS_DTBSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const double* a, + const fortran_int_t* lda, double* x, const fortran_int_t* incx ); +void BLAS_CTBSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const void* a, + const fortran_int_t* lda, void* x, const fortran_int_t* incx ); +void BLAS_ZTBSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const void* a, + const fortran_int_t* lda, void* x, const fortran_int_t* incx ); + +// Value-type variants of tpmv +void BLAS_STPMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const float* ap, float* x, + const fortran_int_t* incx ); +void BLAS_DTPMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const double* ap, double* x, + const fortran_int_t* incx ); +void BLAS_CTPMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* ap, void* x, + const fortran_int_t* incx ); +void BLAS_ZTPMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* ap, void* x, + const fortran_int_t* incx ); + +// Value-type variants of tpsv +void BLAS_STPSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const float* ap, float* x, + const fortran_int_t* incx ); +void BLAS_DTPSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const double* ap, double* x, + const fortran_int_t* incx ); +void BLAS_CTPSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* ap, void* x, + const fortran_int_t* incx ); +void BLAS_ZTPSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* ap, void* x, + const fortran_int_t* incx ); + +// Value-type variants of trmv +void BLAS_STRMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const float* a, const fortran_int_t* lda, + float* x, const fortran_int_t* incx ); +void BLAS_DTRMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const double* a, const fortran_int_t* lda, + double* x, const fortran_int_t* incx ); +void BLAS_CTRMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + void* x, const fortran_int_t* incx ); +void BLAS_ZTRMV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + void* x, const fortran_int_t* incx ); + +// Value-type variants of trsv +void BLAS_STRSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const float* a, const fortran_int_t* lda, + float* x, const fortran_int_t* incx ); +void BLAS_DTRSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const double* a, const fortran_int_t* lda, + double* x, const fortran_int_t* incx ); +void BLAS_CTRSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + void* x, const fortran_int_t* incx ); +void BLAS_ZTRSV( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + void* x, const fortran_int_t* incx ); + +// +// BLAS level3 routines +// + +// Value-type variants of gemm +void BLAS_SGEMM( const char* transa, const char* transb, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const float* alpha, const float* a, + const fortran_int_t* lda, const float* b, const fortran_int_t* ldb, + const float* beta, float* c, const fortran_int_t* ldc ); +void BLAS_DGEMM( const char* transa, const char* transb, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const double* alpha, const double* a, + const fortran_int_t* lda, const double* b, const fortran_int_t* ldb, + const double* beta, double* c, const fortran_int_t* ldc ); +void BLAS_CGEMM( const char* transa, const char* transb, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); +void BLAS_ZGEMM( const char* transa, const char* transb, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); + +// Value-type variants of hemm +void BLAS_CHEMM( const char* side, const char* uplo, const fortran_int_t* m, + const fortran_int_t* n, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); +void BLAS_ZHEMM( const char* side, const char* uplo, const fortran_int_t* m, + const fortran_int_t* n, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); + +// Value-type variants of her2k +void BLAS_CHER2K( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const float* beta, void* c, const fortran_int_t* ldc ); +void BLAS_ZHER2K( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const double* beta, void* c, const fortran_int_t* ldc ); + +// Value-type variants of herk +void BLAS_CHERK( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const float* alpha, const void* a, + const fortran_int_t* lda, const float* beta, void* c, + const fortran_int_t* ldc ); +void BLAS_ZHERK( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const double* alpha, const void* a, + const fortran_int_t* lda, const double* beta, void* c, + const fortran_int_t* ldc ); + +// Value-type variants of symm +void BLAS_SSYMM( const char* side, const char* uplo, const fortran_int_t* m, + const fortran_int_t* n, const float* alpha, const float* a, + const fortran_int_t* lda, const float* b, const fortran_int_t* ldb, + const float* beta, float* c, const fortran_int_t* ldc ); +void BLAS_DSYMM( const char* side, const char* uplo, const fortran_int_t* m, + const fortran_int_t* n, const double* alpha, const double* a, + const fortran_int_t* lda, const double* b, const fortran_int_t* ldb, + const double* beta, double* c, const fortran_int_t* ldc ); +void BLAS_CSYMM( const char* side, const char* uplo, const fortran_int_t* m, + const fortran_int_t* n, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); +void BLAS_ZSYMM( const char* side, const char* uplo, const fortran_int_t* m, + const fortran_int_t* n, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); + +// Value-type variants of syr2k +void BLAS_SSYR2K( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const float* alpha, const float* a, + const fortran_int_t* lda, const float* b, const fortran_int_t* ldb, + const float* beta, float* c, const fortran_int_t* ldc ); +void BLAS_DSYR2K( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const double* alpha, const double* a, + const fortran_int_t* lda, const double* b, const fortran_int_t* ldb, + const double* beta, double* c, const fortran_int_t* ldc ); +void BLAS_CSYR2K( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); +void BLAS_ZSYR2K( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* beta, void* c, const fortran_int_t* ldc ); + +// Value-type variants of syrk +void BLAS_SSYRK( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const float* alpha, const float* a, + const fortran_int_t* lda, const float* beta, float* c, + const fortran_int_t* ldc ); +void BLAS_DSYRK( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const double* alpha, const double* a, + const fortran_int_t* lda, const double* beta, double* c, + const fortran_int_t* ldc ); +void BLAS_CSYRK( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* beta, void* c, + const fortran_int_t* ldc ); +void BLAS_ZSYRK( const char* uplo, const char* trans, const fortran_int_t* n, + const fortran_int_t* k, const void* alpha, const void* a, + const fortran_int_t* lda, const void* beta, void* c, + const fortran_int_t* ldc ); + +// Value-type variants of trmm +void BLAS_STRMM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const float* alpha, const float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb ); +void BLAS_DTRMM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const double* alpha, const double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb ); +void BLAS_CTRMM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb ); +void BLAS_ZTRMM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb ); + +// Value-type variants of trsm +void BLAS_STRSM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const float* alpha, const float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb ); +void BLAS_DTRSM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const double* alpha, const double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb ); +void BLAS_CTRSM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb ); +void BLAS_ZTRSM( const char* side, const char* uplo, const char* transa, + const char* diag, const fortran_int_t* m, const fortran_int_t* n, + const void* alpha, const void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb ); + +} + +#endif + diff --git a/sdk/boost/numeric/bindings/blas/detail/blas_names.h b/sdk/boost/numeric/bindings/blas/detail/blas_names.h new file mode 100644 index 0000000..98de1a5 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/blas_names.h @@ -0,0 +1,275 @@ +// +// Copyright (c) 2003--2009 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_NAMES_H +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_NAMES_H + +#include + +// +// BLAS level1 routines +// + +// Value-type variants of asum +#define BLAS_SASUM FORTRAN_ID2( sasum, SASUM ) +#define BLAS_DASUM FORTRAN_ID2( dasum, DASUM ) +#define BLAS_SCASUM FORTRAN_ID2( scasum, SCASUM ) +#define BLAS_DZASUM FORTRAN_ID2( dzasum, DZASUM ) + +// Value-type variants of axpy +#define BLAS_SAXPY FORTRAN_ID2( saxpy, SAXPY ) +#define BLAS_DAXPY FORTRAN_ID2( daxpy, DAXPY ) +#define BLAS_CAXPY FORTRAN_ID2( caxpy, CAXPY ) +#define BLAS_ZAXPY FORTRAN_ID2( zaxpy, ZAXPY ) + +// Value-type variants of copy +#define BLAS_SCOPY FORTRAN_ID2( scopy, SCOPY ) +#define BLAS_DCOPY FORTRAN_ID2( dcopy, DCOPY ) +#define BLAS_CCOPY FORTRAN_ID2( ccopy, CCOPY ) +#define BLAS_ZCOPY FORTRAN_ID2( zcopy, ZCOPY ) + +// Value-type variants of dot +#define BLAS_SDOT FORTRAN_ID2( sdot, SDOT ) +#define BLAS_DDOT FORTRAN_ID2( ddot, DDOT ) +#define BLAS_CDOTU FORTRAN_ID2( cdotu, CDOTU ) +#define BLAS_ZDOTU FORTRAN_ID2( zdotu, ZDOTU ) + +// Value-type variants of dotc +#define BLAS_CDOTC FORTRAN_ID2( cdotc, CDOTC ) +#define BLAS_ZDOTC FORTRAN_ID2( zdotc, ZDOTC ) + +// Value-type variants of iamax +#define BLAS_ISAMAX FORTRAN_ID2( isamax, ISAMAX ) +#define BLAS_IDAMAX FORTRAN_ID2( idamax, IDAMAX ) +#define BLAS_ICAMAX FORTRAN_ID2( icamax, ICAMAX ) +#define BLAS_IZAMAX FORTRAN_ID2( izamax, IZAMAX ) + +// Value-type variants of nrm2 +#define BLAS_SNRM2 FORTRAN_ID2( snrm2, SNRM2 ) +#define BLAS_DNRM2 FORTRAN_ID2( dnrm2, DNRM2 ) +#define BLAS_SCNRM2 FORTRAN_ID2( scnrm2, SCNRM2 ) +#define BLAS_DZNRM2 FORTRAN_ID2( dznrm2, DZNRM2 ) + +// Value-type variants of prec_dot +#define BLAS_DSDOT FORTRAN_ID2( dsdot, DSDOT ) + +// Value-type variants of rot +#define BLAS_SROT FORTRAN_ID2( srot, SROT ) +#define BLAS_DROT FORTRAN_ID2( drot, DROT ) +#define BLAS_CSROT FORTRAN_ID2( csrot, CSROT ) +#define BLAS_ZDROT FORTRAN_ID2( zdrot, ZDROT ) + +// Value-type variants of rotg +#define BLAS_SROTG FORTRAN_ID2( srotg, SROTG ) +#define BLAS_DROTG FORTRAN_ID2( drotg, DROTG ) +#define BLAS_CROTG FORTRAN_ID2( crotg, CROTG ) +#define BLAS_ZROTG FORTRAN_ID2( zrotg, ZROTG ) + +// Value-type variants of rotm +#define BLAS_SROTM FORTRAN_ID2( srotm, SROTM ) +#define BLAS_DROTM FORTRAN_ID2( drotm, DROTM ) + +// Value-type variants of rotmg +#define BLAS_SROTMG FORTRAN_ID2( srotmg, SROTMG ) +#define BLAS_DROTMG FORTRAN_ID2( drotmg, DROTMG ) + +// Value-type variants of scal +#define BLAS_SSCAL FORTRAN_ID2( sscal, SSCAL ) +#define BLAS_DSCAL FORTRAN_ID2( dscal, DSCAL ) +#define BLAS_CSSCAL FORTRAN_ID2( csscal, CSSCAL ) +#define BLAS_ZDSCAL FORTRAN_ID2( zdscal, ZDSCAL ) +#define BLAS_CSCAL FORTRAN_ID2( cscal, CSCAL ) +#define BLAS_ZSCAL FORTRAN_ID2( zscal, ZSCAL ) + +// Value-type variants of swap +#define BLAS_SSWAP FORTRAN_ID2( sswap, SSWAP ) +#define BLAS_DSWAP FORTRAN_ID2( dswap, DSWAP ) +#define BLAS_CSWAP FORTRAN_ID2( cswap, CSWAP ) +#define BLAS_ZSWAP FORTRAN_ID2( zswap, ZSWAP ) + +// +// BLAS level2 routines +// + +// Value-type variants of gbmv +#define BLAS_SGBMV FORTRAN_ID2( sgbmv, SGBMV ) +#define BLAS_DGBMV FORTRAN_ID2( dgbmv, DGBMV ) +#define BLAS_CGBMV FORTRAN_ID2( cgbmv, CGBMV ) +#define BLAS_ZGBMV FORTRAN_ID2( zgbmv, ZGBMV ) + +// Value-type variants of gemv +#define BLAS_SGEMV FORTRAN_ID2( sgemv, SGEMV ) +#define BLAS_DGEMV FORTRAN_ID2( dgemv, DGEMV ) +#define BLAS_CGEMV FORTRAN_ID2( cgemv, CGEMV ) +#define BLAS_ZGEMV FORTRAN_ID2( zgemv, ZGEMV ) + +// Value-type variants of ger +#define BLAS_SGER FORTRAN_ID2( sger, SGER ) +#define BLAS_DGER FORTRAN_ID2( dger, DGER ) + +// Value-type variants of gerc +#define BLAS_CGERC FORTRAN_ID2( cgerc, CGERC ) +#define BLAS_ZGERC FORTRAN_ID2( zgerc, ZGERC ) + +// Value-type variants of geru +#define BLAS_CGERU FORTRAN_ID2( cgeru, CGERU ) +#define BLAS_ZGERU FORTRAN_ID2( zgeru, ZGERU ) + +// Value-type variants of hbmv +#define BLAS_CHBMV FORTRAN_ID2( chbmv, CHBMV ) +#define BLAS_ZHBMV FORTRAN_ID2( zhbmv, ZHBMV ) + +// Value-type variants of hemv +#define BLAS_CHEMV FORTRAN_ID2( chemv, CHEMV ) +#define BLAS_ZHEMV FORTRAN_ID2( zhemv, ZHEMV ) + +// Value-type variants of her +#define BLAS_CHER FORTRAN_ID2( cher, CHER ) +#define BLAS_ZHER FORTRAN_ID2( zher, ZHER ) + +// Value-type variants of her2 +#define BLAS_CHER2 FORTRAN_ID2( cher2, CHER2 ) +#define BLAS_ZHER2 FORTRAN_ID2( zher2, ZHER2 ) + +// Value-type variants of hpmv +#define BLAS_CHPMV FORTRAN_ID2( chpmv, CHPMV ) +#define BLAS_ZHPMV FORTRAN_ID2( zhpmv, ZHPMV ) + +// Value-type variants of hpr +#define BLAS_CHPR FORTRAN_ID2( chpr, CHPR ) +#define BLAS_ZHPR FORTRAN_ID2( zhpr, ZHPR ) + +// Value-type variants of hpr2 +#define BLAS_CHPR2 FORTRAN_ID2( chpr2, CHPR2 ) +#define BLAS_ZHPR2 FORTRAN_ID2( zhpr2, ZHPR2 ) + +// Value-type variants of sbmv +#define BLAS_SSBMV FORTRAN_ID2( ssbmv, SSBMV ) +#define BLAS_DSBMV FORTRAN_ID2( dsbmv, DSBMV ) + +// Value-type variants of spmv +#define BLAS_SSPMV FORTRAN_ID2( sspmv, SSPMV ) +#define BLAS_DSPMV FORTRAN_ID2( dspmv, DSPMV ) + +// Value-type variants of spr +#define BLAS_SSPR FORTRAN_ID2( sspr, SSPR ) +#define BLAS_DSPR FORTRAN_ID2( dspr, DSPR ) + +// Value-type variants of spr2 +#define BLAS_SSPR2 FORTRAN_ID2( sspr2, SSPR2 ) +#define BLAS_DSPR2 FORTRAN_ID2( dspr2, DSPR2 ) + +// Value-type variants of symv +#define BLAS_SSYMV FORTRAN_ID2( ssymv, SSYMV ) +#define BLAS_DSYMV FORTRAN_ID2( dsymv, DSYMV ) + +// Value-type variants of syr +#define BLAS_SSYR FORTRAN_ID2( ssyr, SSYR ) +#define BLAS_DSYR FORTRAN_ID2( dsyr, DSYR ) + +// Value-type variants of syr2 +#define BLAS_SSYR2 FORTRAN_ID2( ssyr2, SSYR2 ) +#define BLAS_DSYR2 FORTRAN_ID2( dsyr2, DSYR2 ) + +// Value-type variants of tbmv +#define BLAS_STBMV FORTRAN_ID2( stbmv, STBMV ) +#define BLAS_DTBMV FORTRAN_ID2( dtbmv, DTBMV ) +#define BLAS_CTBMV FORTRAN_ID2( ctbmv, CTBMV ) +#define BLAS_ZTBMV FORTRAN_ID2( ztbmv, ZTBMV ) + +// Value-type variants of tbsv +#define BLAS_STBSV FORTRAN_ID2( stbsv, STBSV ) +#define BLAS_DTBSV FORTRAN_ID2( dtbsv, DTBSV ) +#define BLAS_CTBSV FORTRAN_ID2( ctbsv, CTBSV ) +#define BLAS_ZTBSV FORTRAN_ID2( ztbsv, ZTBSV ) + +// Value-type variants of tpmv +#define BLAS_STPMV FORTRAN_ID2( stpmv, STPMV ) +#define BLAS_DTPMV FORTRAN_ID2( dtpmv, DTPMV ) +#define BLAS_CTPMV FORTRAN_ID2( ctpmv, CTPMV ) +#define BLAS_ZTPMV FORTRAN_ID2( ztpmv, ZTPMV ) + +// Value-type variants of tpsv +#define BLAS_STPSV FORTRAN_ID2( stpsv, STPSV ) +#define BLAS_DTPSV FORTRAN_ID2( dtpsv, DTPSV ) +#define BLAS_CTPSV FORTRAN_ID2( ctpsv, CTPSV ) +#define BLAS_ZTPSV FORTRAN_ID2( ztpsv, ZTPSV ) + +// Value-type variants of trmv +#define BLAS_STRMV FORTRAN_ID2( strmv, STRMV ) +#define BLAS_DTRMV FORTRAN_ID2( dtrmv, DTRMV ) +#define BLAS_CTRMV FORTRAN_ID2( ctrmv, CTRMV ) +#define BLAS_ZTRMV FORTRAN_ID2( ztrmv, ZTRMV ) + +// Value-type variants of trsv +#define BLAS_STRSV FORTRAN_ID2( strsv, STRSV ) +#define BLAS_DTRSV FORTRAN_ID2( dtrsv, DTRSV ) +#define BLAS_CTRSV FORTRAN_ID2( ctrsv, CTRSV ) +#define BLAS_ZTRSV FORTRAN_ID2( ztrsv, ZTRSV ) + +// +// BLAS level3 routines +// + +// Value-type variants of gemm +#define BLAS_SGEMM FORTRAN_ID2( sgemm, SGEMM ) +#define BLAS_DGEMM FORTRAN_ID2( dgemm, DGEMM ) +#define BLAS_CGEMM FORTRAN_ID2( cgemm, CGEMM ) +#define BLAS_ZGEMM FORTRAN_ID2( zgemm, ZGEMM ) + +// Value-type variants of hemm +#define BLAS_CHEMM FORTRAN_ID2( chemm, CHEMM ) +#define BLAS_ZHEMM FORTRAN_ID2( zhemm, ZHEMM ) + +// Value-type variants of her2k +#define BLAS_CHER2K FORTRAN_ID2( cher2k, CHER2K ) +#define BLAS_ZHER2K FORTRAN_ID2( zher2k, ZHER2K ) + +// Value-type variants of herk +#define BLAS_CHERK FORTRAN_ID2( cherk, CHERK ) +#define BLAS_ZHERK FORTRAN_ID2( zherk, ZHERK ) + +// Value-type variants of symm +#define BLAS_SSYMM FORTRAN_ID2( ssymm, SSYMM ) +#define BLAS_DSYMM FORTRAN_ID2( dsymm, DSYMM ) +#define BLAS_CSYMM FORTRAN_ID2( csymm, CSYMM ) +#define BLAS_ZSYMM FORTRAN_ID2( zsymm, ZSYMM ) + +// Value-type variants of syr2k +#define BLAS_SSYR2K FORTRAN_ID2( ssyr2k, SSYR2K ) +#define BLAS_DSYR2K FORTRAN_ID2( dsyr2k, DSYR2K ) +#define BLAS_CSYR2K FORTRAN_ID2( csyr2k, CSYR2K ) +#define BLAS_ZSYR2K FORTRAN_ID2( zsyr2k, ZSYR2K ) + +// Value-type variants of syrk +#define BLAS_SSYRK FORTRAN_ID2( ssyrk, SSYRK ) +#define BLAS_DSYRK FORTRAN_ID2( dsyrk, DSYRK ) +#define BLAS_CSYRK FORTRAN_ID2( csyrk, CSYRK ) +#define BLAS_ZSYRK FORTRAN_ID2( zsyrk, ZSYRK ) + +// Value-type variants of trmm +#define BLAS_STRMM FORTRAN_ID2( strmm, STRMM ) +#define BLAS_DTRMM FORTRAN_ID2( dtrmm, DTRMM ) +#define BLAS_CTRMM FORTRAN_ID2( ctrmm, CTRMM ) +#define BLAS_ZTRMM FORTRAN_ID2( ztrmm, ZTRMM ) + +// Value-type variants of trsm +#define BLAS_STRSM FORTRAN_ID2( strsm, STRSM ) +#define BLAS_DTRSM FORTRAN_ID2( dtrsm, DTRSM ) +#define BLAS_CTRSM FORTRAN_ID2( ctrsm, CTRSM ) +#define BLAS_ZTRSM FORTRAN_ID2( ztrsm, ZTRSM ) + + + +#endif + diff --git a/sdk/boost/numeric/bindings/blas/detail/blas_option.hpp b/sdk/boost/numeric/bindings/blas/detail/blas_option.hpp new file mode 100644 index 0000000..b27440a --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/blas_option.hpp @@ -0,0 +1,57 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_OPTION_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_BLAS_OPTION_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { +namespace detail { + +template< typename Tag > +struct blas_option {}; + +template<> +struct blas_option< tag::transpose >: mpl::char_< 'T' > {}; + +template<> +struct blas_option< tag::no_transpose >: mpl::char_< 'N' > {}; + +template<> +struct blas_option< tag::conjugate >: mpl::char_< 'C' > {}; + +template<> +struct blas_option< tag::upper >: mpl::char_< 'U' > {}; + +template<> +struct blas_option< tag::lower >: mpl::char_< 'L' > {}; + +template<> +struct blas_option< tag::unit >: mpl::char_< 'U' > {}; + +template<> +struct blas_option< tag::non_unit >: mpl::char_< 'N' > {}; + +template<> +struct blas_option< tag::left >: mpl::char_< 'L' > {}; + +template<> +struct blas_option< tag::right >: mpl::char_< 'R' > {}; + +} // namespace detail +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/detail/cblas.h b/sdk/boost/numeric/bindings/blas/detail/cblas.h new file mode 100644 index 0000000..e4194dc --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/cblas.h @@ -0,0 +1,41 @@ +/* + * + * Copyright (c) Kresimir Fresl 2002 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Author acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_CBLAS_H +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_CBLAS_H + +// +// MKL-specific CBLAS include +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_MKL + +extern "C" { +#include +#include +// +// mkl_types.h defines P4 macro which breaks MPL, undefine it here. +// +#undef P4 +} + +// +// Default CBLAS include +// +#else + +extern "C" { +#include +} + +#endif +#endif diff --git a/sdk/boost/numeric/bindings/blas/detail/cblas_option.hpp b/sdk/boost/numeric/bindings/blas/detail/cblas_option.hpp new file mode 100644 index 0000000..19420d1 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/cblas_option.hpp @@ -0,0 +1,85 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_CBLAS_OPTION_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_CBLAS_OPTION_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { +namespace detail { + +template< typename Tag > +struct cblas_option {}; + +template<> +struct cblas_option< tag::row_major > { + static const CBLAS_ORDER value = CblasRowMajor; +}; + +template<> +struct cblas_option< tag::column_major > { + static const CBLAS_ORDER value = CblasColMajor; +}; + +template<> +struct cblas_option< tag::transpose > { + static const CBLAS_TRANSPOSE value = CblasTrans; +}; + +template<> +struct cblas_option< tag::no_transpose > { + static const CBLAS_TRANSPOSE value = CblasNoTrans; +}; + +template<> +struct cblas_option< tag::conjugate > { + static const CBLAS_TRANSPOSE value = CblasConjTrans; +}; + +template<> +struct cblas_option< tag::upper > { + static const CBLAS_UPLO value = CblasUpper; +}; + +template<> +struct cblas_option< tag::lower > { + static const CBLAS_UPLO value = CblasLower; +}; + +template<> +struct cblas_option< tag::unit > { + static const CBLAS_DIAG value = CblasUnit; +}; + +template<> +struct cblas_option< tag::non_unit > { + static const CBLAS_DIAG value = CblasNonUnit; +}; + +template<> +struct cblas_option< tag::left > { + static const CBLAS_SIDE value = CblasLeft; +}; + +template<> +struct cblas_option< tag::right > { + static const CBLAS_SIDE value = CblasRight; +}; + +} // namespace detail +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/detail/cublas.h b/sdk/boost/numeric/bindings/blas/detail/cublas.h new file mode 100644 index 0000000..0f46bcb --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/cublas.h @@ -0,0 +1,16 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_CUBLAS_H +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_CUBLAS_H + +extern "C" { +#include +} + +#endif diff --git a/sdk/boost/numeric/bindings/blas/detail/default_order.hpp b/sdk/boost/numeric/bindings/blas/detail/default_order.hpp new file mode 100644 index 0000000..7d3f176 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/detail/default_order.hpp @@ -0,0 +1,38 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_DEFAULT_ORDER_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_DETAIL_DEFAULT_ORDER_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { +namespace detail { + +template< typename T > +struct default_order { + typedef typename mpl::if_< + bindings::detail::is_same_at< T, tag::value_transform, tag::conjugate >, + typename mpl::if_< is_row_major< T >, tag::column_major, tag::row_major >::type, + tag::column_major + >::type type; +}; + +} // namespace detail +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1.hpp b/sdk/boost/numeric/bindings/blas/level1.hpp new file mode 100644 index 0000000..54e8bc5 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1.hpp @@ -0,0 +1,29 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/asum.hpp b/sdk/boost/numeric/bindings/blas/level1/asum.hpp new file mode 100644 index 0000000..a7e3ea4 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/asum.hpp @@ -0,0 +1,230 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ASUM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ASUM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline float asum( const int n, const float* x, const int incx ) { + return cblas_sasum( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline double asum( const int n, const double* x, const int incx ) { + return cblas_dasum( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline float asum( const int n, const std::complex* x, + const int incx ) { + return cblas_scasum( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline double asum( const int n, const std::complex* x, + const int incx ) { + return cblas_dzasum( n, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline float asum( const int n, const float* x, const int incx ) { + return cublasSasum( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline double asum( const int n, const double* x, const int incx ) { + return cublasDasum( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline float asum( const int n, const std::complex* x, + const int incx ) { + return cublasScasum( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline double asum( const int n, const std::complex* x, + const int incx ) { + return cublasDzasum( n, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline float asum( const fortran_int_t n, const float* x, + const fortran_int_t incx ) { + return BLAS_SASUM( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline double asum( const fortran_int_t n, const double* x, + const fortran_int_t incx ) { + return BLAS_DASUM( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline float asum( const fortran_int_t n, const std::complex* x, + const fortran_int_t incx ) { + return BLAS_SCASUM( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline double asum( const fortran_int_t n, const std::complex* x, + const fortran_int_t incx ) { + return BLAS_DZASUM( &n, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to asum. +// +template< typename Value > +struct asum_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef real_type result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX > + static result_type invoke( const VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + return detail::asum( bindings::size(x), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the asum_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for asum. Its overload differs for +// +template< typename VectorX > +inline typename asum_impl< typename bindings::value_type< + VectorX >::type >::result_type +asum( const VectorX& x ) { + return asum_impl< typename bindings::value_type< + VectorX >::type >::invoke( x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/axpy.hpp b/sdk/boost/numeric/bindings/blas/level1/axpy.hpp new file mode 100644 index 0000000..f5c605c --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/axpy.hpp @@ -0,0 +1,249 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_AXPY_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_AXPY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void axpy( const int n, const float a, const float* x, const int incx, + float* y, const int incy ) { + cblas_saxpy( n, a, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void axpy( const int n, const double a, const double* x, + const int incx, double* y, const int incy ) { + cblas_daxpy( n, a, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void axpy( const int n, const std::complex a, + const std::complex* x, const int incx, std::complex* y, + const int incy ) { + cblas_caxpy( n, &a, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void axpy( const int n, const std::complex a, + const std::complex* x, const int incx, + std::complex* y, const int incy ) { + cblas_zaxpy( n, &a, x, incx, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void axpy( const int n, const float a, const float* x, const int incx, + float* y, const int incy ) { + cublasSaxpy( n, a, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void axpy( const int n, const double a, const double* x, + const int incx, double* y, const int incy ) { + cublasDaxpy( n, a, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void axpy( const int n, const std::complex a, + const std::complex* x, const int incx, std::complex* y, + const int incy ) { + cublasCaxpy( n, a, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void axpy( const int n, const std::complex a, + const std::complex* x, const int incx, + std::complex* y, const int incy ) { + cublasZaxpy( n, a, x, incx, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void axpy( const fortran_int_t n, const float a, const float* x, + const fortran_int_t incx, float* y, const fortran_int_t incy ) { + BLAS_SAXPY( &n, &a, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void axpy( const fortran_int_t n, const double a, const double* x, + const fortran_int_t incx, double* y, const fortran_int_t incy ) { + BLAS_DAXPY( &n, &a, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void axpy( const fortran_int_t n, const std::complex a, + const std::complex* x, const fortran_int_t incx, + std::complex* y, const fortran_int_t incy ) { + BLAS_CAXPY( &n, &a, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void axpy( const fortran_int_t n, const std::complex a, + const std::complex* x, const fortran_int_t incx, + std::complex* y, const fortran_int_t incy ) { + BLAS_ZAXPY( &n, &a, x, &incx, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to axpy. +// +template< typename Value > +struct axpy_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( const value_type a, const VectorX& x, + VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + detail::axpy( bindings::size(x), a, bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the axpy_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for axpy. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename axpy_impl< typename bindings::value_type< + VectorX >::type >::result_type +axpy( const typename bindings::value_type< VectorX >::type a, + const VectorX& x, VectorY& y ) { + axpy_impl< typename bindings::value_type< + VectorX >::type >::invoke( a, x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/copy.hpp b/sdk/boost/numeric/bindings/blas/level1/copy.hpp new file mode 100644 index 0000000..4d9ae20 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/copy.hpp @@ -0,0 +1,243 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_COPY_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_COPY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void copy( const int n, const float* x, const int incx, float* y, + const int incy ) { + cblas_scopy( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void copy( const int n, const double* x, const int incx, double* y, + const int incy ) { + cblas_dcopy( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void copy( const int n, const std::complex* x, const int incx, + std::complex* y, const int incy ) { + cblas_ccopy( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void copy( const int n, const std::complex* x, const int incx, + std::complex* y, const int incy ) { + cblas_zcopy( n, x, incx, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void copy( const int n, const float* x, const int incx, float* y, + const int incy ) { + cublasScopy( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void copy( const int n, const double* x, const int incx, double* y, + const int incy ) { + cublasDcopy( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void copy( const int n, const std::complex* x, const int incx, + std::complex* y, const int incy ) { + cublasCcopy( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void copy( const int n, const std::complex* x, const int incx, + std::complex* y, const int incy ) { + cublasZcopy( n, x, incx, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void copy( const fortran_int_t n, const float* x, + const fortran_int_t incx, float* y, const fortran_int_t incy ) { + BLAS_SCOPY( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void copy( const fortran_int_t n, const double* x, + const fortran_int_t incx, double* y, const fortran_int_t incy ) { + BLAS_DCOPY( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void copy( const fortran_int_t n, const std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy ) { + BLAS_CCOPY( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void copy( const fortran_int_t n, const std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy ) { + BLAS_ZCOPY( &n, x, &incx, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to copy. +// +template< typename Value > +struct copy_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( const VectorX& x, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + detail::copy( bindings::size(x), bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the copy_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for copy. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename copy_impl< typename bindings::value_type< + VectorX >::type >::result_type +copy( const VectorX& x, VectorY& y ) { + copy_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/dot.hpp b/sdk/boost/numeric/bindings/blas/level1/dot.hpp new file mode 100644 index 0000000..5d84f48 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/dot.hpp @@ -0,0 +1,246 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOT_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOT_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline float dot( const int n, const float* x, const int incx, const float* y, + const int incy ) { + return cblas_sdot( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline double dot( const int n, const double* x, const int incx, + const double* y, const int incy ) { + return cblas_ddot( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline std::complex dot( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + std::complex result; + cblas_cdotu_sub( n, x, incx, y, incy, &result ); + return result; +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline std::complex dot( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + std::complex result; + cblas_zdotu_sub( n, x, incx, y, incy, &result ); + return result; +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline float dot( const int n, const float* x, const int incx, const float* y, + const int incy ) { + return cublasSdot( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline double dot( const int n, const double* x, const int incx, + const double* y, const int incy ) { + return cublasDdot( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline std::complex dot( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + return cublasCdotu( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline std::complex dot( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + return cublasZdotu( n, x, incx, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline float dot( const fortran_int_t n, const float* x, + const fortran_int_t incx, const float* y, const fortran_int_t incy ) { + return BLAS_SDOT( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline double dot( const fortran_int_t n, const double* x, + const fortran_int_t incx, const double* y, const fortran_int_t incy ) { + return BLAS_DDOT( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline std::complex dot( const fortran_int_t n, + const std::complex* x, const fortran_int_t incx, + const std::complex* y, const fortran_int_t incy ) { + return BLAS_CDOTU( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline std::complex dot( const fortran_int_t n, + const std::complex* x, const fortran_int_t incx, + const std::complex* y, const fortran_int_t incy ) { + return BLAS_ZDOTU( &n, x, &incx, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to dot. +// +template< typename Value > +struct dot_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef value_type result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( const VectorX& x, const VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + return detail::dot( bindings::size(x), + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the dot_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for dot. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename dot_impl< typename bindings::value_type< + VectorX >::type >::result_type +dot( const VectorX& x, const VectorY& y ) { + return dot_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/dotc.hpp b/sdk/boost/numeric/bindings/blas/level1/dotc.hpp new file mode 100644 index 0000000..229045f --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/dotc.hpp @@ -0,0 +1,186 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOTC_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOTC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline std::complex dotc( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + std::complex result; + cblas_cdotc_sub( n, x, incx, y, incy, &result ); + return result; +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline std::complex dotc( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + std::complex result; + cblas_zdotc_sub( n, x, incx, y, incy, &result ); + return result; +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline std::complex dotc( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + return cublasCdotc( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline std::complex dotc( const int n, const std::complex* x, + const int incx, const std::complex* y, const int incy ) { + return cublasZdotc( n, x, incx, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline std::complex dotc( const fortran_int_t n, + const std::complex* x, const fortran_int_t incx, + const std::complex* y, const fortran_int_t incy ) { + return BLAS_CDOTC( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline std::complex dotc( const fortran_int_t n, + const std::complex* x, const fortran_int_t incx, + const std::complex* y, const fortran_int_t incy ) { + return BLAS_ZDOTC( &n, x, &incx, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to dotc. +// +template< typename Value > +struct dotc_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef value_type result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( const VectorX& x, const VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + return detail::dotc( bindings::size(x), + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the dotc_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for dotc. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename dotc_impl< typename bindings::value_type< + VectorX >::type >::result_type +dotc( const VectorX& x, const VectorY& y ) { + return dotc_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/dotu.hpp b/sdk/boost/numeric/bindings/blas/level1/dotu.hpp new file mode 100644 index 0000000..5956860 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/dotu.hpp @@ -0,0 +1,42 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOTU_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_DOTU_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// dotu is a synonym for dot +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. +// + +// +// Overloaded function for dotu. +// +template< typename VectorX, typename VectorY > +inline typename dot_impl< typename bindings::value_type< VectorX >::type >::result_type +dotu( const VectorX& x, const VectorY& y ) { + return dot_impl< typename bindings::value_type< VectorX >::type >::invoke( x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/iamax.hpp b/sdk/boost/numeric/bindings/blas/level1/iamax.hpp new file mode 100644 index 0000000..5eaec0c --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/iamax.hpp @@ -0,0 +1,232 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_IAMAX_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_IAMAX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline std::ptrdiff_t iamax( const int n, const float* x, const int incx ) { + return cblas_isamax( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline std::ptrdiff_t iamax( const int n, const double* x, + const int incx ) { + return cblas_idamax( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline std::ptrdiff_t iamax( const int n, const std::complex* x, + const int incx ) { + return cblas_icamax( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline std::ptrdiff_t iamax( const int n, const std::complex* x, + const int incx ) { + return cblas_izamax( n, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline std::ptrdiff_t iamax( const int n, const float* x, const int incx ) { + return cublasIsamax( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline std::ptrdiff_t iamax( const int n, const double* x, + const int incx ) { + return cublasIdamax( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline std::ptrdiff_t iamax( const int n, const std::complex* x, + const int incx ) { + return cublasIcamax( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline std::ptrdiff_t iamax( const int n, const std::complex* x, + const int incx ) { + return cublasIzamax( n, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t iamax( const fortran_int_t n, const float* x, + const fortran_int_t incx ) { + return BLAS_ISAMAX( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t iamax( const fortran_int_t n, const double* x, + const fortran_int_t incx ) { + return BLAS_IDAMAX( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t iamax( const fortran_int_t n, + const std::complex* x, const fortran_int_t incx ) { + return BLAS_ICAMAX( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t iamax( const fortran_int_t n, + const std::complex* x, const fortran_int_t incx ) { + return BLAS_IZAMAX( &n, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to iamax. +// +template< typename Value > +struct iamax_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef std::ptrdiff_t result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX > + static result_type invoke( const VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + return detail::iamax( bindings::size(x), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the iamax_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for iamax. Its overload differs for +// +template< typename VectorX > +inline typename iamax_impl< typename bindings::value_type< + VectorX >::type >::result_type +iamax( const VectorX& x ) { + return iamax_impl< typename bindings::value_type< + VectorX >::type >::invoke( x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/nrm2.hpp b/sdk/boost/numeric/bindings/blas/level1/nrm2.hpp new file mode 100644 index 0000000..fb02dd3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/nrm2.hpp @@ -0,0 +1,230 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_NRM2_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_NRM2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline float nrm2( const int n, const float* x, const int incx ) { + return cblas_snrm2( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline double nrm2( const int n, const double* x, const int incx ) { + return cblas_dnrm2( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline float nrm2( const int n, const std::complex* x, + const int incx ) { + return cblas_scnrm2( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline double nrm2( const int n, const std::complex* x, + const int incx ) { + return cblas_dznrm2( n, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline float nrm2( const int n, const float* x, const int incx ) { + return cublasSnrm2( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline double nrm2( const int n, const double* x, const int incx ) { + return cublasDnrm2( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline float nrm2( const int n, const std::complex* x, + const int incx ) { + return cublasScnrm2( n, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline double nrm2( const int n, const std::complex* x, + const int incx ) { + return cublasDznrm2( n, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline float nrm2( const fortran_int_t n, const float* x, + const fortran_int_t incx ) { + return BLAS_SNRM2( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline double nrm2( const fortran_int_t n, const double* x, + const fortran_int_t incx ) { + return BLAS_DNRM2( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline float nrm2( const fortran_int_t n, const std::complex* x, + const fortran_int_t incx ) { + return BLAS_SCNRM2( &n, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline double nrm2( const fortran_int_t n, const std::complex* x, + const fortran_int_t incx ) { + return BLAS_DZNRM2( &n, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to nrm2. +// +template< typename Value > +struct nrm2_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef real_type result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX > + static result_type invoke( const VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + return detail::nrm2( bindings::size(x), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the nrm2_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for nrm2. Its overload differs for +// +template< typename VectorX > +inline typename nrm2_impl< typename bindings::value_type< + VectorX >::type >::result_type +nrm2( const VectorX& x ) { + return nrm2_impl< typename bindings::value_type< + VectorX >::type >::invoke( x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/prec_dot.hpp b/sdk/boost/numeric/bindings/blas/level1/prec_dot.hpp new file mode 100644 index 0000000..d57eb58 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/prec_dot.hpp @@ -0,0 +1,150 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_PREC_DOT_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_PREC_DOT_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline double prec_dot( const int n, const float* x, const int incx, + const float* y, const int incy ) { + return cblas_dsdot( n, x, incx, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline double prec_dot( const int n, const float* x, const int incx, + const float* y, const int incy ) { + return // NOT FOUND(); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline double prec_dot( const fortran_int_t n, const float* x, + const fortran_int_t incx, const float* y, const fortran_int_t incy ) { + return BLAS_DSDOT( &n, x, &incx, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to prec_dot. +// +template< typename Value > +struct prec_dot_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef double result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( const VectorX& x, const VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + return detail::prec_dot( bindings::size(x), + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the prec_dot_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for prec_dot. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename prec_dot_impl< typename bindings::value_type< + VectorX >::type >::result_type +prec_dot( const VectorX& x, const VectorY& y ) { + return prec_dot_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/rot.hpp b/sdk/boost/numeric/bindings/blas/level1/rot.hpp new file mode 100644 index 0000000..db0349a --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/rot.hpp @@ -0,0 +1,250 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROT_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROT_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void rot( const int n, float* x, const int incx, float* y, + const int incy, const float c, const float s ) { + cblas_srot( n, x, incx, y, incy, c, s ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void rot( const int n, double* x, const int incx, double* y, + const int incy, const double c, const double s ) { + cblas_drot( n, x, incx, y, incy, c, s ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void rot( const int n, std::complex* x, const int incx, + std::complex* y, const int incy, const float c, + const float s ) { + // NOT FOUND(); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void rot( const int n, std::complex* x, const int incx, + std::complex* y, const int incy, const double c, + const double s ) { + // NOT FOUND(); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void rot( const int n, float* x, const int incx, float* y, + const int incy, const float c, const float s ) { + cublasSrot( n, x, incx, y, incy, c, s ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void rot( const int n, double* x, const int incx, double* y, + const int incy, const double c, const double s ) { + cublasDrot( n, x, incx, y, incy, c, s ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void rot( const int n, std::complex* x, const int incx, + std::complex* y, const int incy, const float c, + const float s ) { + cublasCsrot( n, x, incx, y, incy, c, s ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void rot( const int n, std::complex* x, const int incx, + std::complex* y, const int incy, const double c, + const double s ) { + cublasZdrot( n, x, incx, y, incy, c, s ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void rot( const fortran_int_t n, float* x, const fortran_int_t incx, + float* y, const fortran_int_t incy, const float c, const float s ) { + BLAS_SROT( &n, x, &incx, y, &incy, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void rot( const fortran_int_t n, double* x, const fortran_int_t incx, + double* y, const fortran_int_t incy, const double c, const double s ) { + BLAS_DROT( &n, x, &incx, y, &incy, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void rot( const fortran_int_t n, std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy, const float c, const float s ) { + BLAS_CSROT( &n, x, &incx, y, &incy, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void rot( const fortran_int_t n, std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy, const double c, const double s ) { + BLAS_ZDROT( &n, x, &incx, y, &incy, &c, &s ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to rot. +// +template< typename Value > +struct rot_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( VectorX& x, VectorY& y, const real_type c, + const real_type s ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + detail::rot( bindings::size(x), bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), c, s ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the rot_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for rot. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename rot_impl< typename bindings::value_type< + VectorX >::type >::result_type +rot( VectorX& x, VectorY& y, const typename remove_imaginary< + typename bindings::value_type< VectorX >::type >::type c, + const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type s ) { + rot_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y, c, s ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/rotg.hpp b/sdk/boost/numeric/bindings/blas/level1/rotg.hpp new file mode 100644 index 0000000..229d78c --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/rotg.hpp @@ -0,0 +1,223 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTG_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTG_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void rotg( float& a, float& b, float& c, float& s ) { + cblas_srotg( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void rotg( double& a, double& b, double& c, double& s ) { + cblas_drotg( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void rotg( std::complex& a, std::complex& b, float& c, + std::complex& s ) { + // NOT FOUND(); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void rotg( std::complex& a, std::complex& b, double& c, + std::complex& s ) { + // NOT FOUND(); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void rotg( float& a, float& b, float& c, float& s ) { + cublasSrotg( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void rotg( double& a, double& b, double& c, double& s ) { + cublasDrotg( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void rotg( std::complex& a, std::complex& b, float& c, + std::complex& s ) { + cublasCrotg( &a, b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void rotg( std::complex& a, std::complex& b, double& c, + std::complex& s ) { + cublasZrotg( &a, b, &c, &s ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void rotg( float& a, float& b, float& c, float& s ) { + BLAS_SROTG( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void rotg( double& a, double& b, double& c, double& s ) { + BLAS_DROTG( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void rotg( std::complex& a, std::complex& b, float& c, + std::complex& s ) { + BLAS_CROTG( &a, &b, &c, &s ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void rotg( std::complex& a, std::complex& b, double& c, + std::complex& s ) { + BLAS_ZROTG( &a, &b, &c, &s ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to rotg. +// +template< typename Value > +struct rotg_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + static result_type invoke( value_type& a, value_type& b, real_type& c, + value_type& s ) { + namespace bindings = ::boost::numeric::bindings; + detail::rotg( a, b, c, s ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the rotg_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for rotg. Its overload differs for +// +template< typename Value > +inline typename rotg_impl< Value >::result_type +rotg( Value& a, Value& b, Value& c, Value& s ) { + rotg_impl< Value >::invoke( a, b, c, s ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/rotm.hpp b/sdk/boost/numeric/bindings/blas/level1/rotm.hpp new file mode 100644 index 0000000..05fc3be --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/rotm.hpp @@ -0,0 +1,187 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void rotm( const int n, float* x, const int incx, float* y, + const int incy, float* param ) { + cblas_srotm( n, x, incx, y, incy, param ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void rotm( const int n, double* x, const int incx, double* y, + const int incy, double* param ) { + cblas_drotm( n, x, incx, y, incy, param ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void rotm( const int n, float* x, const int incx, float* y, + const int incy, float* param ) { + cublasSrotm( n, x, incx, y, incy, param ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void rotm( const int n, double* x, const int incx, double* y, + const int incy, double* param ) { + cublasDrotm( n, x, incx, y, incy, param ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void rotm( const fortran_int_t n, float* x, const fortran_int_t incx, + float* y, const fortran_int_t incy, float* param ) { + BLAS_SROTM( &n, x, &incx, y, &incy, param ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void rotm( const fortran_int_t n, double* x, const fortran_int_t incx, + double* y, const fortran_int_t incy, double* param ) { + BLAS_DROTM( &n, x, &incx, y, &incy, param ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to rotm. +// +template< typename Value > +struct rotm_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename VectorPARAM > + static result_type invoke( VectorX& x, VectorY& y, VectorPARAM& param ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorPARAM >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorPARAM >::value) ); + detail::rotm( bindings::size(x), bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), bindings::begin_value(param) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the rotm_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for rotm. Its overload differs for +// +template< typename VectorX, typename VectorY, typename VectorPARAM > +inline typename rotm_impl< typename bindings::value_type< + VectorX >::type >::result_type +rotm( VectorX& x, VectorY& y, VectorPARAM& param ) { + rotm_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y, param ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/rotmg.hpp b/sdk/boost/numeric/bindings/blas/level1/rotmg.hpp new file mode 100644 index 0000000..0fdecc5 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/rotmg.hpp @@ -0,0 +1,179 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTMG_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_ROTMG_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void rotmg( float& d1, float& d2, float& x1, const float y1, + float* sparam ) { + cblas_srotmg( &d1, &d2, &x1, y1, sparam ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void rotmg( double& d1, double& d2, double& x1, const double y1, + double* dparam ) { + cblas_drotmg( &d1, &d2, &x1, y1, dparam ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void rotmg( float& d1, float& d2, float& x1, const float y1, + float* sparam ) { + cublasSrotmg( &d1, &d2, &x1, &y1, sparam ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void rotmg( double& d1, double& d2, double& x1, const double y1, + double* dparam ) { + cublasDrotmg( &d1, &d2, &x1, &y1, dparam ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void rotmg( float& d1, float& d2, float& x1, const float y1, + float* sparam ) { + BLAS_SROTMG( &d1, &d2, &x1, &y1, sparam ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void rotmg( double& d1, double& d2, double& x1, const double y1, + double* dparam ) { + BLAS_DROTMG( &d1, &d2, &x1, &y1, dparam ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to rotmg. +// +template< typename Value > +struct rotmg_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorDPARAM > + static result_type invoke( real_type& d1, real_type& d2, real_type& x1, + const real_type y1, VectorDPARAM& dparam ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDPARAM >::value) ); + detail::rotmg( d1, d2, x1, y1, bindings::begin_value(dparam) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the rotmg_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for rotmg. Its overload differs for +// +template< typename VectorDPARAM > +inline typename rotmg_impl< typename bindings::value_type< + VectorDPARAM >::type >::result_type +rotmg( typename remove_imaginary< typename bindings::value_type< + VectorDPARAM >::type >::type& d1, typename remove_imaginary< + typename bindings::value_type< VectorDPARAM >::type >::type& d2, + typename remove_imaginary< typename bindings::value_type< + VectorDPARAM >::type >::type& x1, const typename remove_imaginary< + typename bindings::value_type< VectorDPARAM >::type >::type y1, + VectorDPARAM& dparam ) { + rotmg_impl< typename bindings::value_type< + VectorDPARAM >::type >::invoke( d1, d2, x1, y1, dparam ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/scal.hpp b/sdk/boost/numeric/bindings/blas/level1/scal.hpp new file mode 100644 index 0000000..5684836 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/scal.hpp @@ -0,0 +1,291 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SCAL_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SCAL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void scal( const int n, const float a, float* x, const int incx ) { + cblas_sscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void scal( const int n, const double a, double* x, const int incx ) { + cblas_dscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * combined float and complex value-type. +// +inline void scal( const int n, const float a, std::complex* x, + const int incx ) { + cblas_csscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * combined double and complex value-type. +// +inline void scal( const int n, const double a, std::complex* x, + const int incx ) { + cblas_zdscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void scal( const int n, const std::complex a, + std::complex* x, const int incx ) { + cblas_cscal( n, &a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void scal( const int n, const std::complex a, + std::complex* x, const int incx ) { + cblas_zscal( n, &a, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void scal( const int n, const float a, float* x, const int incx ) { + cublasSscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void scal( const int n, const double a, double* x, const int incx ) { + cublasDscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * combined float and complex value-type. +// +inline void scal( const int n, const float a, std::complex* x, + const int incx ) { + cublasCsscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * combined double and complex value-type. +// +inline void scal( const int n, const double a, std::complex* x, + const int incx ) { + cublasZdscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void scal( const int n, const std::complex a, + std::complex* x, const int incx ) { + cublasCscal( n, a, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void scal( const int n, const std::complex a, + std::complex* x, const int incx ) { + cublasZscal( n, a, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void scal( const fortran_int_t n, const float a, float* x, + const fortran_int_t incx ) { + BLAS_SSCAL( &n, &a, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void scal( const fortran_int_t n, const double a, double* x, + const fortran_int_t incx ) { + BLAS_DSCAL( &n, &a, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * combined float and complex value-type. +// +inline void scal( const fortran_int_t n, const float a, + std::complex* x, const fortran_int_t incx ) { + BLAS_CSSCAL( &n, &a, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * combined double and complex value-type. +// +inline void scal( const fortran_int_t n, const double a, + std::complex* x, const fortran_int_t incx ) { + BLAS_ZDSCAL( &n, &a, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void scal( const fortran_int_t n, const std::complex a, + std::complex* x, const fortran_int_t incx ) { + BLAS_CSCAL( &n, &a, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void scal( const fortran_int_t n, const std::complex a, + std::complex* x, const fortran_int_t incx ) { + BLAS_ZSCAL( &n, &a, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to scal. +// +template< typename Value > +struct scal_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename ScalarA, typename VectorX > + static result_type invoke( const ScalarA a, VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + detail::scal( bindings::size(x), a, bindings::begin_value(x), + bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the scal_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for scal. Its overload differs for +// +template< typename ScalarA, typename VectorX > +inline typename scal_impl< typename bindings::value_type< + VectorX >::type >::result_type +scal( const ScalarA a, VectorX& x ) { + scal_impl< typename bindings::value_type< + VectorX >::type >::invoke( a, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/set.hpp b/sdk/boost/numeric/bindings/blas/level1/set.hpp new file mode 100644 index 0000000..05fccb8 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/set.hpp @@ -0,0 +1,62 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SET_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SET_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// set is an extension, not part of the BLAS API. +// +// TODO implement ATLAS backend call(s) +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. +// + +// +// Overloaded function for set. Its overload differs for +// * VectorX& +// +template< typename VectorX > +inline void +set( const typename bindings::value_type< VectorX >::type a, VectorX& x ) { + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + std::fill( bindings::begin(x), bindings::end(x), a ); +} + +// +// Overloaded function for set. Its overload differs for +// * const VectorX& +// +template< typename VectorX > +inline void +set( const typename bindings::value_type< const VectorX >::type a, const VectorX& x ) { + BOOST_STATIC_ASSERT( (bindings::is_mutable< const VectorX >::value) ); + std::fill( bindings::begin(x), bindings::end(x), a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level1/swap.hpp b/sdk/boost/numeric/bindings/blas/level1/swap.hpp new file mode 100644 index 0000000..ba5f8d3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level1/swap.hpp @@ -0,0 +1,244 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SWAP_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL1_SWAP_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +inline void swap( const int n, float* x, const int incx, float* y, + const int incy ) { + cblas_sswap( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +inline void swap( const int n, double* x, const int incx, double* y, + const int incy ) { + cblas_dswap( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void swap( const int n, std::complex* x, const int incx, + std::complex* y, const int incy ) { + cblas_cswap( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +inline void swap( const int n, std::complex* x, const int incx, + std::complex* y, const int incy ) { + cblas_zswap( n, x, incx, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +inline void swap( const int n, float* x, const int incx, float* y, + const int incy ) { + cublasSswap( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +inline void swap( const int n, double* x, const int incx, double* y, + const int incy ) { + cublasDswap( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void swap( const int n, std::complex* x, const int incx, + std::complex* y, const int incy ) { + cublasCswap( n, x, incx, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +inline void swap( const int n, std::complex* x, const int incx, + std::complex* y, const int incy ) { + cublasZswap( n, x, incx, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +inline void swap( const fortran_int_t n, float* x, const fortran_int_t incx, + float* y, const fortran_int_t incy ) { + BLAS_SSWAP( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +inline void swap( const fortran_int_t n, double* x, const fortran_int_t incx, + double* y, const fortran_int_t incy ) { + BLAS_DSWAP( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void swap( const fortran_int_t n, std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy ) { + BLAS_CSWAP( &n, x, &incx, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +inline void swap( const fortran_int_t n, std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy ) { + BLAS_ZSWAP( &n, x, &incx, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to swap. +// +template< typename Value > +struct swap_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY > + static result_type invoke( VectorX& x, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + detail::swap( bindings::size(x), bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the swap_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for swap. Its overload differs for +// +template< typename VectorX, typename VectorY > +inline typename swap_impl< typename bindings::value_type< + VectorX >::type >::result_type +swap( VectorX& x, VectorY& y ) { + swap_impl< typename bindings::value_type< + VectorX >::type >::invoke( x, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2.hpp b/sdk/boost/numeric/bindings/blas/level2.hpp new file mode 100644 index 0000000..e734e08 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2.hpp @@ -0,0 +1,38 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/gbmv.hpp b/sdk/boost/numeric/bindings/blas/level2/gbmv.hpp new file mode 100644 index 0000000..a7a951c --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/gbmv.hpp @@ -0,0 +1,332 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GBMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GBMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const float alpha, const float* a, + const int lda, const float* x, const int incx, const float beta, + float* y, const int incy ) { + cblas_sgbmv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const double alpha, const double* a, + const int lda, const double* x, const int incx, const double beta, + double* y, const int incy ) { + cblas_dgbmv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_cgbmv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, kl, ku, &alpha, a, lda, x, incx, &beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_zgbmv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, kl, ku, &alpha, a, lda, x, incx, &beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const float alpha, const float* a, + const int lda, const float* x, const int incx, const float beta, + float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x, + incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const double alpha, const double* a, + const int lda, const double* x, const int incx, const double beta, + double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x, + incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x, + incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const int m, const int n, + const int kl, const int ku, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZgbmv( blas_option< Trans >::value, m, n, kl, ku, alpha, a, lda, x, + incx, beta, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const float alpha, const float* a, const fortran_int_t lda, + const float* x, const fortran_int_t incx, const float beta, float* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a, + &lda, x, &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const double alpha, const double* a, const fortran_int_t lda, + const double* x, const fortran_int_t incx, const double beta, + double* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a, + &lda, x, &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* x, + const fortran_int_t incx, const std::complex beta, + std::complex* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a, + &lda, x, &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gbmv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* x, + const fortran_int_t incx, const std::complex beta, + std::complex* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZGBMV( &blas_option< Trans >::value, &m, &n, &kl, &ku, &alpha, a, + &lda, x, &incx, &beta, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbmv. +// +template< typename Value > +struct gbmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type invoke( const value_type alpha, const MatrixA& a, + const VectorX& x, const value_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_band_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::gbmv( order(), trans(), bindings::size_row_op(a, + trans()), bindings::size_column_op(a, trans()), + bindings::bandwidth_lower_op(a, trans()), + bindings::bandwidth_upper_op(a, trans()), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x), beta, + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the gbmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbmv. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorY > +inline typename gbmv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +gbmv( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const VectorX& x, + const typename bindings::value_type< MatrixA >::type beta, + VectorY& y ) { + gbmv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/gemv.hpp b/sdk/boost/numeric/bindings/blas/level2/gemv.hpp new file mode 100644 index 0000000..c36dff0 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/gemv.hpp @@ -0,0 +1,325 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GEMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GEMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const float alpha, const float* a, const int lda, const float* x, + const int incx, const float beta, float* y, const int incy ) { + cblas_sgemv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const double alpha, const double* a, const int lda, const double* x, + const int incx, const double beta, double* y, const int incy ) { + cblas_dgemv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_cgemv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, &alpha, a, lda, x, incx, &beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_zgemv( cblas_option< Order >::value, cblas_option< Trans >::value, + m, n, &alpha, a, lda, x, incx, &beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const float alpha, const float* a, const int lda, const float* x, + const int incx, const float beta, float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const double alpha, const double* a, const int lda, const double* x, + const int incx, const double beta, double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZgemv( blas_option< Trans >::value, m, n, alpha, a, lda, x, incx, + beta, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const float alpha, const float* a, + const fortran_int_t lda, const float* x, const fortran_int_t incx, + const float beta, float* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const double alpha, const double* a, + const fortran_int_t lda, const double* x, const fortran_int_t incx, + const double beta, double* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* x, const fortran_int_t incx, + const std::complex beta, std::complex* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Trans > +inline void gemv( const Order, const Trans, const fortran_int_t m, + const fortran_int_t n, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* x, const fortran_int_t incx, + const std::complex beta, std::complex* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZGEMV( &blas_option< Trans >::value, &m, &n, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gemv. +// +template< typename Value > +struct gemv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // high-level transform typedefs and functions + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type transform( MatrixA& A, VectorX& x, VectorY& y, + const value_type alpha, const value_type beta ) { + invoke(); + } + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type invoke( const value_type alpha, const MatrixA& a, + const VectorX& x, const value_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::gemv( order(), trans(), bindings::size_row_op(a, + trans()), bindings::size_column_op(a, trans()), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x), beta, + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the gemv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gemv. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorY > +inline typename gemv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +gemv( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const VectorX& x, + const typename bindings::value_type< MatrixA >::type beta, + VectorY& y ) { + gemv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/ger.hpp b/sdk/boost/numeric/bindings/blas/level2/ger.hpp new file mode 100644 index 0000000..04b52e0 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/ger.hpp @@ -0,0 +1,215 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GER_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GER_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order > +inline void ger( const Order, const int m, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* a, const int lda ) { + cblas_sger( cblas_option< Order >::value, m, n, alpha, x, incx, y, incy, + a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order > +inline void ger( const Order, const int m, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* a, const int lda ) { + cblas_dger( cblas_option< Order >::value, m, n, alpha, x, incx, y, incy, + a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order > +inline void ger( const Order, const int m, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSger( m, n, alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order > +inline void ger( const Order, const int m, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDger( m, n, alpha, x, incx, y, incy, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order > +inline void ger( const Order, const fortran_int_t m, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + const float* y, const fortran_int_t incy, float* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SGER( &m, &n, &alpha, x, &incx, y, &incy, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order > +inline void ger( const Order, const fortran_int_t m, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + const double* y, const fortran_int_t incy, double* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DGER( &m, &n, &alpha, x, &incx, y, &incy, a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ger. +// +template< typename Value > +struct ger_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixA > + static result_type invoke( const real_type alpha, const VectorX& x, + const VectorY& y, MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::ger( order(), bindings::size_row(a), + bindings::size_column(a), alpha, bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), bindings::begin_value(a), + bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the ger_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ger. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixA > +inline typename ger_impl< typename bindings::value_type< + VectorX >::type >::result_type +ger( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, const VectorY& y, + MatrixA& a ) { + ger_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/gerc.hpp b/sdk/boost/numeric/bindings/blas/level2/gerc.hpp new file mode 100644 index 0000000..c32f1cd --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/gerc.hpp @@ -0,0 +1,220 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GERC_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GERC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void gerc( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + cblas_cgerc( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy, + a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void gerc( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + cblas_zgerc( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy, + a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void gerc( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCgerc( m, n, alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void gerc( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZgerc( m, n, alpha, x, incx, y, incy, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order > +inline void gerc( const Order, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CGERC( &m, &n, &alpha, x, &incx, y, &incy, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order > +inline void gerc( const Order, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZGERC( &m, &n, &alpha, x, &incx, y, &incy, a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gerc. +// +template< typename Value > +struct gerc_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixA > + static result_type invoke( const value_type alpha, const VectorX& x, + const VectorY& y, MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::gerc( order(), bindings::size_row(a), + bindings::size_column(a), alpha, bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), bindings::begin_value(a), + bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the gerc_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gerc. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixA > +inline typename gerc_impl< typename bindings::value_type< + VectorX >::type >::result_type +gerc( const typename bindings::value_type< VectorX >::type alpha, + const VectorX& x, const VectorY& y, MatrixA& a ) { + gerc_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/geru.hpp b/sdk/boost/numeric/bindings/blas/level2/geru.hpp new file mode 100644 index 0000000..1880744 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/geru.hpp @@ -0,0 +1,220 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GERU_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_GERU_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void geru( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + cblas_cgeru( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy, + a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void geru( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + cblas_zgeru( cblas_option< Order >::value, m, n, &alpha, x, incx, y, incy, + a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void geru( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCgeru( m, n, alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order > +inline void geru( const Order, const int m, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZgeru( m, n, alpha, x, incx, y, incy, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order > +inline void geru( const Order, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CGERU( &m, &n, &alpha, x, &incx, y, &incy, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order > +inline void geru( const Order, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZGERU( &m, &n, &alpha, x, &incx, y, &incy, a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geru. +// +template< typename Value > +struct geru_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixA > + static result_type invoke( const value_type alpha, const VectorX& x, + const VectorY& y, MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::geru( order(), bindings::size_row(a), + bindings::size_column(a), alpha, bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), bindings::begin_value(a), + bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the geru_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geru. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixA > +inline typename geru_impl< typename bindings::value_type< + VectorX >::type >::result_type +geru( const typename bindings::value_type< VectorX >::type alpha, + const VectorX& x, const VectorY& y, MatrixA& a ) { + geru_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/hbmv.hpp b/sdk/boost/numeric/bindings/blas/level2/hbmv.hpp new file mode 100644 index 0000000..96adca4 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/hbmv.hpp @@ -0,0 +1,320 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HBMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HBMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const float alpha, const float* a, const int lda, const float* x, + const int incx, const float beta, float* y, const int incy ) { + cblas_ssbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + k, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const double alpha, const double* a, const int lda, const double* x, + const int incx, const double beta, double* y, const int incy ) { + cblas_dsbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + k, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_chbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + k, &alpha, a, lda, x, incx, &beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_zhbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + k, &alpha, a, lda, x, incx, &beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const float alpha, const float* a, const int lda, const float* x, + const int incx, const float beta, float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const double alpha, const double* a, const int lda, const double* x, + const int incx, const double beta, double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasChbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const int n, const int k, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZhbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx, + beta, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const fortran_int_t n, + const fortran_int_t k, const float alpha, const float* a, + const fortran_int_t lda, const float* x, const fortran_int_t incx, + const float beta, float* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const fortran_int_t n, + const fortran_int_t k, const double alpha, const double* a, + const fortran_int_t lda, const double* x, const fortran_int_t incx, + const double beta, double* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const fortran_int_t n, + const fortran_int_t k, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* x, const fortran_int_t incx, + const std::complex beta, std::complex* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hbmv( const Order, const UpLo, const fortran_int_t n, + const fortran_int_t k, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* x, const fortran_int_t incx, + const std::complex beta, std::complex* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbmv. +// +template< typename Value > +struct hbmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type invoke( const value_type alpha, const MatrixA& a, + const VectorX& x, const value_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_band_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::hbmv( order(), uplo(), bindings::size_column(a), + bindings::bandwidth_upper(a), alpha, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(x), + bindings::stride(x), beta, bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the hbmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbmv. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorY > +inline typename hbmv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +hbmv( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const VectorX& x, + const typename bindings::value_type< MatrixA >::type beta, + VectorY& y ) { + hbmv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/hemv.hpp b/sdk/boost/numeric/bindings/blas/level2/hemv.hpp new file mode 100644 index 0000000..fab7788 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/hemv.hpp @@ -0,0 +1,315 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HEMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HEMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, const float alpha, + const float* a, const int lda, const float* x, const int incx, + const float beta, float* y, const int incy ) { + cblas_ssymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, const double alpha, + const double* a, const int lda, const double* x, const int incx, + const double beta, double* y, const int incy ) { + cblas_dsymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_chemv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, a, lda, x, incx, &beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_zhemv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, a, lda, x, incx, &beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, const float alpha, + const float* a, const int lda, const float* x, const int incx, + const float beta, float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsymv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta, + y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, const double alpha, + const double* a, const int lda, const double* x, const int incx, + const double beta, double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsymv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta, + y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasChemv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta, + y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* a, + const int lda, const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZhemv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta, + y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* a, const fortran_int_t lda, + const float* x, const fortran_int_t incx, const float beta, float* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx, + &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* a, const fortran_int_t lda, + const double* x, const fortran_int_t incx, const double beta, + double* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx, + &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* x, + const fortran_int_t incx, const std::complex beta, + std::complex* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHEMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx, + &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hemv( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* x, + const fortran_int_t incx, const std::complex beta, + std::complex* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHEMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx, + &beta, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hemv. +// +template< typename Value > +struct hemv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type invoke( const value_type alpha, const MatrixA& a, + const VectorX& x, const value_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::hemv( order(), uplo(), bindings::size_column(a), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x), beta, + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the hemv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hemv. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorY > +inline typename hemv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +hemv( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const VectorX& x, + const typename bindings::value_type< MatrixA >::type beta, + VectorY& y ) { + hemv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/her.hpp b/sdk/boost/numeric/bindings/blas/level2/her.hpp new file mode 100644 index 0000000..bbfdac0 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/her.hpp @@ -0,0 +1,283 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HER_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HER_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* a, const int lda ) { + cblas_ssyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* a, const int lda ) { + cblas_dsyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const float alpha, + const std::complex* x, const int incx, std::complex* a, + const int lda ) { + cblas_cher( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const double alpha, + const std::complex* x, const int incx, + std::complex* a, const int lda ) { + cblas_zher( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const float alpha, + const std::complex* x, const int incx, std::complex* a, + const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCher( blas_option< UpLo >::value, n, alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const int n, const double alpha, + const std::complex* x, const int incx, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZher( blas_option< UpLo >::value, n, alpha, x, incx, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, float* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + double* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const fortran_int_t n, + const float alpha, const std::complex* x, + const fortran_int_t incx, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHER( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her( const Order, const UpLo, const fortran_int_t n, + const double alpha, const std::complex* x, + const fortran_int_t incx, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHER( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to her. +// +template< typename Value > +struct her_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename MatrixA > + static result_type invoke( const real_type alpha, const VectorX& x, + MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::her( order(), uplo(), bindings::size_column(a), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(a), bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the her_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for her. Its overload differs for +// +template< typename VectorX, typename MatrixA > +inline typename her_impl< typename bindings::value_type< + VectorX >::type >::result_type +her( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, MatrixA& a ) { + her_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/her2.hpp b/sdk/boost/numeric/bindings/blas/level2/her2.hpp new file mode 100644 index 0000000..8cf68c3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/her2.hpp @@ -0,0 +1,309 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HER2_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HER2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* a, const int lda ) { + cblas_ssyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* a, const int lda ) { + cblas_dsyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + cblas_cher2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + cblas_zher2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, x, incx, y, incy, a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a, + lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a, + lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCher2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a, + lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZher2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a, + lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + const float* y, const fortran_int_t incy, float* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + const double* y, const fortran_int_t incy, double* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHER2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void her2( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHER2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to her2. +// +template< typename Value > +struct her2_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixA > + static result_type invoke( const value_type alpha, const VectorX& x, + const VectorY& y, MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::her2( order(), uplo(), bindings::size_column(a), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y), + bindings::begin_value(a), bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the her2_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for her2. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixA > +inline typename her2_impl< typename bindings::value_type< + VectorX >::type >::result_type +her2( const typename bindings::value_type< VectorX >::type alpha, + const VectorX& x, const VectorY& y, MatrixA& a ) { + her2_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/hpmv.hpp b/sdk/boost/numeric/bindings/blas/level2/hpmv.hpp new file mode 100644 index 0000000..9d7dc5a --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/hpmv.hpp @@ -0,0 +1,315 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, const float alpha, + const float* ap, const float* x, const int incx, const float beta, + float* y, const int incy ) { + cblas_sspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, ap, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, const double alpha, + const double* ap, const double* x, const int incx, const double beta, + double* y, const int incy ) { + cblas_dspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, ap, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* ap, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_chpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, ap, x, incx, &beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* ap, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + cblas_zhpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, ap, x, incx, &beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, const float alpha, + const float* ap, const float* x, const int incx, const float beta, + float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSspmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y, + incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, const double alpha, + const double* ap, const double* x, const int incx, const double beta, + double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDspmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y, + incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* ap, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasChpmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y, + incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* ap, + const std::complex* x, const int incx, + const std::complex beta, std::complex* y, + const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZhpmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y, + incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* ap, const float* x, + const fortran_int_t incx, const float beta, float* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta, + y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* ap, const double* x, + const fortran_int_t incx, const double beta, double* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta, + y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* ap, + const std::complex* x, const fortran_int_t incx, + const std::complex beta, std::complex* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta, + y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpmv( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* ap, + const std::complex* x, const fortran_int_t incx, + const std::complex beta, std::complex* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta, + y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpmv. +// +template< typename Value > +struct hpmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorX, typename VectorY > + static result_type invoke( const value_type alpha, const MatrixAP& ap, + const VectorX& x, const value_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAP >::type order; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + detail::hpmv( order(), uplo(), bindings::size_column(ap), alpha, + bindings::begin_value(ap), bindings::begin_value(x), + bindings::stride(x), beta, bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the hpmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpmv. Its overload differs for +// +template< typename MatrixAP, typename VectorX, typename VectorY > +inline typename hpmv_impl< typename bindings::value_type< + MatrixAP >::type >::result_type +hpmv( const typename bindings::value_type< MatrixAP >::type alpha, + const MatrixAP& ap, const VectorX& x, + const typename bindings::value_type< MatrixAP >::type beta, + VectorY& y ) { + hpmv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( alpha, ap, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/hpr.hpp b/sdk/boost/numeric/bindings/blas/level2/hpr.hpp new file mode 100644 index 0000000..9e4ed3e --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/hpr.hpp @@ -0,0 +1,281 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPR_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* ap ) { + cblas_sspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* ap ) { + cblas_dspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const float alpha, + const std::complex* x, const int incx, + std::complex* ap ) { + cblas_chpr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const double alpha, + const std::complex* x, const int incx, + std::complex* ap ) { + cblas_zhpr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, ap ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSspr( blas_option< UpLo >::value, n, alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDspr( blas_option< UpLo >::value, n, alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const float alpha, + const std::complex* x, const int incx, + std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasChpr( blas_option< UpLo >::value, n, alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const int n, const double alpha, + const std::complex* x, const int incx, + std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZhpr( blas_option< UpLo >::value, n, alpha, x, incx, ap ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const fortran_int_t n, + const float alpha, const std::complex* x, + const fortran_int_t incx, std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr( const Order, const UpLo, const fortran_int_t n, + const double alpha, const std::complex* x, + const fortran_int_t incx, std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpr. +// +template< typename Value > +struct hpr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename MatrixAP > + static result_type invoke( const real_type alpha, const VectorX& x, + MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAP >::type order; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + detail::hpr( order(), uplo(), bindings::size_column(ap), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(ap) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the hpr_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpr. Its overload differs for +// +template< typename VectorX, typename MatrixAP > +inline typename hpr_impl< typename bindings::value_type< + VectorX >::type >::result_type +hpr( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, MatrixAP& ap ) { + hpr_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, ap ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/hpr2.hpp b/sdk/boost/numeric/bindings/blas/level2/hpr2.hpp new file mode 100644 index 0000000..58e6c0e --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/hpr2.hpp @@ -0,0 +1,301 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPR2_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_HPR2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* ap ) { + cblas_sspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* ap ) { + cblas_dspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* ap ) { + cblas_chpr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* ap ) { + cblas_zhpr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + &alpha, x, incx, y, incy, ap ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSspr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDspr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasChpr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const int n, + const std::complex alpha, const std::complex* x, + const int incx, const std::complex* y, const int incy, + std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZhpr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + const float* y, const fortran_int_t incy, float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + const double* y, const fortran_int_t incy, double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline void hpr2( const Order, const UpLo, const fortran_int_t n, + const std::complex alpha, const std::complex* x, + const fortran_int_t incx, const std::complex* y, + const fortran_int_t incy, std::complex* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + ap ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpr2. +// +template< typename Value > +struct hpr2_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixAP > + static result_type invoke( const value_type alpha, const VectorX& x, + const VectorY& y, MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAP >::type order; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + detail::hpr2( order(), uplo(), bindings::size_column(ap), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y), + bindings::begin_value(ap) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the hpr2_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpr2. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixAP > +inline typename hpr2_impl< typename bindings::value_type< + VectorX >::type >::result_type +hpr2( const typename bindings::value_type< VectorX >::type alpha, + const VectorX& x, const VectorY& y, MatrixAP& ap ) { + hpr2_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, ap ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/sbmv.hpp b/sdk/boost/numeric/bindings/blas/level2/sbmv.hpp new file mode 100644 index 0000000..6d320c3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/sbmv.hpp @@ -0,0 +1,224 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SBMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SBMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void sbmv( const Order, const UpLo, const int n, const int k, + const float alpha, const float* a, const int lda, const float* x, + const int incx, const float beta, float* y, const int incy ) { + cblas_ssbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + k, alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void sbmv( const Order, const UpLo, const int n, const int k, + const double alpha, const double* a, const int lda, const double* x, + const int incx, const double beta, double* y, const int incy ) { + cblas_dsbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + k, alpha, a, lda, x, incx, beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void sbmv( const Order, const UpLo, const int n, const int k, + const float alpha, const float* a, const int lda, const float* x, + const int incx, const float beta, float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx, + beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void sbmv( const Order, const UpLo, const int n, const int k, + const double alpha, const double* a, const int lda, const double* x, + const int incx, const double beta, double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsbmv( blas_option< UpLo >::value, n, k, alpha, a, lda, x, incx, + beta, y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void sbmv( const Order, const UpLo, const fortran_int_t n, + const fortran_int_t k, const float alpha, const float* a, + const fortran_int_t lda, const float* x, const fortran_int_t incx, + const float beta, float* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void sbmv( const Order, const UpLo, const fortran_int_t n, + const fortran_int_t k, const double alpha, const double* a, + const fortran_int_t lda, const double* x, const fortran_int_t incx, + const double beta, double* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSBMV( &blas_option< UpLo >::value, &n, &k, &alpha, a, &lda, x, + &incx, &beta, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbmv. +// +template< typename Value > +struct sbmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type invoke( const real_type alpha, const MatrixA& a, + const VectorX& x, const real_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_band_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::sbmv( order(), uplo(), bindings::size_column(a), + bindings::bandwidth_upper(a), alpha, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(x), + bindings::stride(x), beta, bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the sbmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbmv. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorY > +inline typename sbmv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +sbmv( const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type alpha, const MatrixA& a, const VectorX& x, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type beta, VectorY& y ) { + sbmv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/spmv.hpp b/sdk/boost/numeric/bindings/blas/level2/spmv.hpp new file mode 100644 index 0000000..cfe9ebc --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/spmv.hpp @@ -0,0 +1,221 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SPMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SPMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spmv( const Order, const UpLo, const int n, const float alpha, + const float* ap, const float* x, const int incx, const float beta, + float* y, const int incy ) { + cblas_sspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, ap, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spmv( const Order, const UpLo, const int n, const double alpha, + const double* ap, const double* x, const int incx, const double beta, + double* y, const int incy ) { + cblas_dspmv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, ap, x, incx, beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spmv( const Order, const UpLo, const int n, const float alpha, + const float* ap, const float* x, const int incx, const float beta, + float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSspmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y, + incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spmv( const Order, const UpLo, const int n, const double alpha, + const double* ap, const double* x, const int incx, const double beta, + double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDspmv( blas_option< UpLo >::value, n, alpha, ap, x, incx, beta, y, + incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spmv( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* ap, const float* x, + const fortran_int_t incx, const float beta, float* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta, + y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spmv( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* ap, const double* x, + const fortran_int_t incx, const double beta, double* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSPMV( &blas_option< UpLo >::value, &n, &alpha, ap, x, &incx, &beta, + y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spmv. +// +template< typename Value > +struct spmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorX, typename VectorY > + static result_type invoke( const real_type alpha, const MatrixAP& ap, + const VectorX& x, const real_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAP >::type order; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + detail::spmv( order(), uplo(), bindings::size_column(ap), alpha, + bindings::begin_value(ap), bindings::begin_value(x), + bindings::stride(x), beta, bindings::begin_value(y), + bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the spmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spmv. Its overload differs for +// +template< typename MatrixAP, typename VectorX, typename VectorY > +inline typename spmv_impl< typename bindings::value_type< + MatrixAP >::type >::result_type +spmv( const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type alpha, const MatrixAP& ap, const VectorX& x, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type beta, VectorY& y ) { + spmv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( alpha, ap, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/spr.hpp b/sdk/boost/numeric/bindings/blas/level2/spr.hpp new file mode 100644 index 0000000..4174c6e --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/spr.hpp @@ -0,0 +1,203 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SPR_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SPR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spr( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* ap ) { + cblas_sspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spr( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* ap ) { + cblas_dspr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, ap ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spr( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSspr( blas_option< UpLo >::value, n, alpha, x, incx, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spr( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDspr( blas_option< UpLo >::value, n, alpha, x, incx, ap ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spr( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spr( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSPR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, ap ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spr. +// +template< typename Value > +struct spr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename MatrixAP > + static result_type invoke( const real_type alpha, const VectorX& x, + MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAP >::type order; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + detail::spr( order(), uplo(), bindings::size_column(ap), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(ap) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the spr_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spr. Its overload differs for +// +template< typename VectorX, typename MatrixAP > +inline typename spr_impl< typename bindings::value_type< + VectorX >::type >::result_type +spr( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, MatrixAP& ap ) { + spr_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, ap ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/spr2.hpp b/sdk/boost/numeric/bindings/blas/level2/spr2.hpp new file mode 100644 index 0000000..3dc85d3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/spr2.hpp @@ -0,0 +1,216 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SPR2_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SPR2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spr2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* ap ) { + cblas_sspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spr2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* ap ) { + cblas_dspr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, ap ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spr2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSspr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spr2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDspr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, ap ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void spr2( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + const float* y, const fortran_int_t incy, float* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + ap ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void spr2( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + const double* y, const fortran_int_t incy, double* ap ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSPR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + ap ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spr2. +// +template< typename Value > +struct spr2_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixAP > + static result_type invoke( const real_type alpha, const VectorX& x, + const VectorY& y, MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAP >::type order; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + detail::spr2( order(), uplo(), bindings::size_column(ap), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y), + bindings::begin_value(ap) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the spr2_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spr2. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixAP > +inline typename spr2_impl< typename bindings::value_type< + VectorX >::type >::result_type +spr2( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, const VectorY& y, + MatrixAP& ap ) { + spr2_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, ap ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/symv.hpp b/sdk/boost/numeric/bindings/blas/level2/symv.hpp new file mode 100644 index 0000000..3f06b9c --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/symv.hpp @@ -0,0 +1,221 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SYMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SYMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void symv( const Order, const UpLo, const int n, const float alpha, + const float* a, const int lda, const float* x, const int incx, + const float beta, float* y, const int incy ) { + cblas_ssymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, a, lda, x, incx, beta, y, incy ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void symv( const Order, const UpLo, const int n, const double alpha, + const double* a, const int lda, const double* x, const int incx, + const double beta, double* y, const int incy ) { + cblas_dsymv( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, a, lda, x, incx, beta, y, incy ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void symv( const Order, const UpLo, const int n, const float alpha, + const float* a, const int lda, const float* x, const int incx, + const float beta, float* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsymv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta, + y, incy ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void symv( const Order, const UpLo, const int n, const double alpha, + const double* a, const int lda, const double* x, const int incx, + const double beta, double* y, const int incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsymv( blas_option< UpLo >::value, n, alpha, a, lda, x, incx, beta, + y, incy ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void symv( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* a, const fortran_int_t lda, + const float* x, const fortran_int_t incx, const float beta, float* y, + const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx, + &beta, y, &incy ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void symv( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* a, const fortran_int_t lda, + const double* x, const fortran_int_t incx, const double beta, + double* y, const fortran_int_t incy ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYMV( &blas_option< UpLo >::value, &n, &alpha, a, &lda, x, &incx, + &beta, y, &incy ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to symv. +// +template< typename Value > +struct symv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorY > + static result_type invoke( const real_type alpha, const MatrixA& a, + const VectorX& x, const real_type beta, VectorY& y ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::symv( order(), uplo(), bindings::size_column(a), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x), beta, + bindings::begin_value(y), bindings::stride(y) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the symv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for symv. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorY > +inline typename symv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +symv( const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type alpha, const MatrixA& a, const VectorX& x, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type beta, VectorY& y ) { + symv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, x, beta, y ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/syr.hpp b/sdk/boost/numeric/bindings/blas/level2/syr.hpp new file mode 100644 index 0000000..60c2d26 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/syr.hpp @@ -0,0 +1,203 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SYR_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SYR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void syr( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* a, const int lda ) { + cblas_ssyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void syr( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* a, const int lda ) { + cblas_dsyr( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void syr( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, float* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void syr( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, double* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyr( blas_option< UpLo >::value, n, alpha, x, incx, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void syr( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, float* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void syr( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + double* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYR( &blas_option< UpLo >::value, &n, &alpha, x, &incx, a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syr. +// +template< typename Value > +struct syr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename MatrixA > + static result_type invoke( const real_type alpha, const VectorX& x, + MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::syr( order(), uplo(), bindings::size_column(a), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(a), bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the syr_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syr. Its overload differs for +// +template< typename VectorX, typename MatrixA > +inline typename syr_impl< typename bindings::value_type< + VectorX >::type >::result_type +syr( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, MatrixA& a ) { + syr_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/syr2.hpp b/sdk/boost/numeric/bindings/blas/level2/syr2.hpp new file mode 100644 index 0000000..dc2f0af --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/syr2.hpp @@ -0,0 +1,220 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SYR2_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_SYR2_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void syr2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* a, const int lda ) { + cblas_ssyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, a, lda ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void syr2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* a, const int lda ) { + cblas_dsyr2( cblas_option< Order >::value, cblas_option< UpLo >::value, n, + alpha, x, incx, y, incy, a, lda ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void syr2( const Order, const UpLo, const int n, const float alpha, + const float* x, const int incx, const float* y, const int incy, + float* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a, + lda ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void syr2( const Order, const UpLo, const int n, const double alpha, + const double* x, const int incx, const double* y, const int incy, + double* a, const int lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyr2( blas_option< UpLo >::value, n, alpha, x, incx, y, incy, a, + lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline void syr2( const Order, const UpLo, const fortran_int_t n, + const float alpha, const float* x, const fortran_int_t incx, + const float* y, const fortran_int_t incy, float* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + a, &lda ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline void syr2( const Order, const UpLo, const fortran_int_t n, + const double alpha, const double* x, const fortran_int_t incx, + const double* y, const fortran_int_t incy, double* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYR2( &blas_option< UpLo >::value, &n, &alpha, x, &incx, y, &incy, + a, &lda ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syr2. +// +template< typename Value > +struct syr2_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename MatrixA > + static result_type invoke( const real_type alpha, const VectorX& x, + const VectorY& y, MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::syr2( order(), uplo(), bindings::size_column(a), alpha, + bindings::begin_value(x), bindings::stride(x), + bindings::begin_value(y), bindings::stride(y), + bindings::begin_value(a), bindings::stride_major(a) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the syr2_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syr2. Its overload differs for +// +template< typename VectorX, typename VectorY, typename MatrixA > +inline typename syr2_impl< typename bindings::value_type< + VectorX >::type >::result_type +syr2( const typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type alpha, const VectorX& x, const VectorY& y, + MatrixA& a ) { + syr2_impl< typename bindings::value_type< + VectorX >::type >::invoke( alpha, x, y, a ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/tbmv.hpp b/sdk/boost/numeric/bindings/blas/level2/tbmv.hpp new file mode 100644 index 0000000..4d2dbeb --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/tbmv.hpp @@ -0,0 +1,305 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TBMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TBMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const float* a, const int lda, float* x, + const int incx ) { + cblas_stbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const double* a, const int lda, double* x, + const int incx ) { + cblas_dtbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + cblas_ctbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, + const int lda, std::complex* x, const int incx ) { + cblas_ztbmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const float* a, const int lda, float* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStbmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const double* a, const int lda, double* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtbmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtbmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, + const int lda, std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtbmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, float* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, double* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTBMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tbmv. +// +template< typename Value > +struct tbmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX > + static result_type invoke( const std::ptrdiff_t k, const MatrixA& a, + VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_band_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::tbmv( order(), uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), k, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the tbmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tbmv. Its overload differs for +// +template< typename MatrixA, typename VectorX > +inline typename tbmv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +tbmv( const std::ptrdiff_t k, const MatrixA& a, VectorX& x ) { + tbmv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( k, a, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/tbsv.hpp b/sdk/boost/numeric/bindings/blas/level2/tbsv.hpp new file mode 100644 index 0000000..f97ac39 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/tbsv.hpp @@ -0,0 +1,305 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TBSV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TBSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const float* a, const int lda, float* x, + const int incx ) { + cblas_stbsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const double* a, const int lda, double* x, + const int incx ) { + cblas_dtbsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + cblas_ctbsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, + const int lda, std::complex* x, const int incx ) { + cblas_ztbsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, k, + a, lda, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const float* a, const int lda, float* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStbsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const double* a, const int lda, double* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtbsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtbsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const int n, const int k, const std::complex* a, + const int lda, std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtbsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, k, a, lda, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, float* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, double* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tbsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTBSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, &k, a, &lda, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tbsv. +// +template< typename Value > +struct tbsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX > + static result_type invoke( const std::ptrdiff_t k, const MatrixA& a, + VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_band_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::tbsv( order(), uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), k, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the tbsv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tbsv. Its overload differs for +// +template< typename MatrixA, typename VectorX > +inline typename tbsv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +tbsv( const std::ptrdiff_t k, const MatrixA& a, VectorX& x ) { + tbsv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( k, a, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/tpmv.hpp b/sdk/boost/numeric/bindings/blas/level2/tpmv.hpp new file mode 100644 index 0000000..ca438df --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/tpmv.hpp @@ -0,0 +1,296 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TPMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TPMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* ap, float* x, const int incx ) { + cblas_stpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* ap, double* x, const int incx ) { + cblas_dtpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + cblas_ctpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + cblas_ztpmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* ap, float* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStpmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* ap, double* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtpmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtpmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtpmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const float* ap, float* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const double* ap, double* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* ap, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* ap, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTPMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tpmv. +// +template< typename Value > +struct tpmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorX > + static result_type invoke( const MatrixAP& ap, VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixAP >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + detail::tpmv( order(), uplo(), trans(), diag(), + bindings::size_column_op(ap, trans()), + bindings::begin_value(ap), bindings::begin_value(x), + bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the tpmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tpmv. Its overload differs for +// +template< typename MatrixAP, typename VectorX > +inline typename tpmv_impl< typename bindings::value_type< + MatrixAP >::type >::result_type +tpmv( const MatrixAP& ap, VectorX& x ) { + tpmv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/tpsv.hpp b/sdk/boost/numeric/bindings/blas/level2/tpsv.hpp new file mode 100644 index 0000000..f1dbc86 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/tpsv.hpp @@ -0,0 +1,296 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TPSV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TPSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* ap, float* x, const int incx ) { + cblas_stpsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* ap, double* x, const int incx ) { + cblas_dtpsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + cblas_ctpsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + cblas_ztpsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, ap, + x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* ap, float* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStpsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* ap, double* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtpsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtpsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* ap, std::complex* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtpsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, ap, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const float* ap, float* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const double* ap, double* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* ap, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void tpsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* ap, + std::complex* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTPSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, ap, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tpsv. +// +template< typename Value > +struct tpsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorX > + static result_type invoke( const MatrixAP& ap, VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixAP >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_triangular_array< + MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + detail::tpsv( order(), uplo(), trans(), diag(), + bindings::size_column_op(ap, trans()), + bindings::begin_value(ap), bindings::begin_value(x), + bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the tpsv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tpsv. Its overload differs for +// +template< typename MatrixAP, typename VectorX > +inline typename tpsv_impl< typename bindings::value_type< + MatrixAP >::type >::result_type +tpsv( const MatrixAP& ap, VectorX& x ) { + tpsv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/trmv.hpp b/sdk/boost/numeric/bindings/blas/level2/trmv.hpp new file mode 100644 index 0000000..2950aa7 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/trmv.hpp @@ -0,0 +1,302 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TRMV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TRMV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* a, const int lda, float* x, + const int incx ) { + cblas_strmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* a, const int lda, double* x, + const int incx ) { + cblas_dtrmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + cblas_ctrmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + cblas_ztrmv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* a, const int lda, float* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStrmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* a, const int lda, double* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtrmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtrmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtrmv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const float* a, const fortran_int_t lda, + float* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const double* a, const fortran_int_t lda, + double* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, std::complex* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trmv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, std::complex* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTRMV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trmv. +// +template< typename Value > +struct trmv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX > + static result_type invoke( const MatrixA& a, VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::trmv( order(), uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the trmv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trmv. Its overload differs for +// +template< typename MatrixA, typename VectorX > +inline typename trmv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +trmv( const MatrixA& a, VectorX& x ) { + trmv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level2/trsv.hpp b/sdk/boost/numeric/bindings/blas/level2/trsv.hpp new file mode 100644 index 0000000..e673573 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level2/trsv.hpp @@ -0,0 +1,302 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TRSV_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL2_TRSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* a, const int lda, float* x, + const int incx ) { + cblas_strsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* a, const int lda, double* x, + const int incx ) { + cblas_dtrsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + cblas_ctrsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + cblas_ztrsv( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, cblas_option< Diag >::value, n, a, + lda, x, incx ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const float* a, const int lda, float* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStrsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const double* a, const int lda, double* x, + const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtrsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtrsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const int n, const std::complex* a, const int lda, + std::complex* x, const int incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtrsv( blas_option< UpLo >::value, blas_option< Trans >::value, + blas_option< Diag >::value, n, a, lda, x, incx ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const float* a, const fortran_int_t lda, + float* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const double* a, const fortran_int_t lda, + double* x, const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, std::complex* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans, typename Diag > +inline void trsv( const Order, const UpLo, const Trans, const Diag, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, std::complex* x, + const fortran_int_t incx ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTRSV( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &blas_option< Diag >::value, &n, a, &lda, x, &incx ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trsv. +// +template< typename Value > +struct trsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX > + static result_type invoke( const MatrixA& a, VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + detail::trsv( order(), uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), bindings::stride(x) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the trsv_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trsv. Its overload differs for +// +template< typename MatrixA, typename VectorX > +inline typename trsv_impl< typename bindings::value_type< + MatrixA >::type >::result_type +trsv( const MatrixA& a, VectorX& x ) { + trsv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, x ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3.hpp b/sdk/boost/numeric/bindings/blas/level3.hpp new file mode 100644 index 0000000..c7b5b75 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3.hpp @@ -0,0 +1,22 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/gemm.hpp b/sdk/boost/numeric/bindings/blas/level3/gemm.hpp new file mode 100644 index 0000000..d119243 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/gemm.hpp @@ -0,0 +1,338 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_GEMM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_GEMM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const float alpha, const float* a, + const int lda, const float* b, const int ldb, const float beta, + float* c, const int ldc ) { + cblas_sgemm( cblas_option< Order >::value, cblas_option< TransA >::value, + cblas_option< TransB >::value, m, n, k, alpha, a, lda, b, ldb, + beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const double alpha, const double* a, + const int lda, const double* b, const int ldb, const double beta, + double* c, const int ldc ) { + cblas_dgemm( cblas_option< Order >::value, cblas_option< TransA >::value, + cblas_option< TransB >::value, m, n, k, alpha, a, lda, b, ldb, + beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_cgemm( cblas_option< Order >::value, cblas_option< TransA >::value, + cblas_option< TransB >::value, m, n, k, &alpha, a, lda, b, ldb, + &beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_zgemm( cblas_option< Order >::value, cblas_option< TransA >::value, + cblas_option< TransB >::value, m, n, k, &alpha, a, lda, b, ldb, + &beta, c, ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const float alpha, const float* a, + const int lda, const float* b, const int ldb, const float beta, + float* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSgemm( blas_option< TransA >::value, blas_option< TransB >::value, + m, n, k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const double alpha, const double* a, + const int lda, const double* b, const int ldb, const double beta, + double* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDgemm( blas_option< TransA >::value, blas_option< TransB >::value, + m, n, k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCgemm( blas_option< TransA >::value, blas_option< TransB >::value, + m, n, k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, const int m, + const int n, const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZgemm( blas_option< TransA >::value, blas_option< TransB >::value, + m, n, k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const float alpha, const float* a, const fortran_int_t lda, + const float* b, const fortran_int_t ldb, const float beta, float* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value, + &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const double alpha, const double* a, const fortran_int_t lda, + const double* b, const fortran_int_t ldb, const double beta, + double* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value, + &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, const std::complex beta, + std::complex* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value, + &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename TransA, typename TransB > +inline void gemm( const Order, const TransA, const TransB, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, const std::complex beta, + std::complex* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZGEMM( &blas_option< TransA >::value, &blas_option< TransB >::value, + &m, &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gemm. +// +template< typename Value > +struct gemm_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC > + static result_type invoke( const value_type alpha, const MatrixA& a, + const MatrixB& b, const value_type beta, MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixB, order >::type transb; + typedef typename result_of::trans_tag< MatrixA, order >::type transa; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::gemm( order(), transa(), transb(), + bindings::size_row(c), bindings::size_column(c), + bindings::size_column(a), alpha, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), beta, bindings::begin_value(c), + bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the gemm_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gemm. Its overload differs for +// +template< typename MatrixA, typename MatrixB, typename MatrixC > +inline typename gemm_impl< typename bindings::value_type< + MatrixA >::type >::result_type +gemm( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const MatrixB& b, + const typename bindings::value_type< MatrixA >::type beta, + MatrixC& c ) { + gemm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, b, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/hemm.hpp b/sdk/boost/numeric/bindings/blas/level3/hemm.hpp new file mode 100644 index 0000000..8c74d2d --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/hemm.hpp @@ -0,0 +1,336 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HEMM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HEMM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + cblas_ssymm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c, + ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + cblas_dsymm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c, + ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_chemm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_zhemm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta, + c, ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsymm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsymm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasChemm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZhemm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const float alpha, const float* a, + const fortran_int_t lda, const float* b, const fortran_int_t ldb, + const float beta, float* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const double alpha, const double* a, + const fortran_int_t lda, const double* b, const fortran_int_t ldb, + const double beta, double* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHEMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void hemm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHEMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hemm. +// +template< typename Value > +struct hemm_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename MatrixB, + typename MatrixC > + static result_type invoke( const Side side, const value_type alpha, + const MatrixA& a, const MatrixB& b, const value_type beta, + MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::hemm( order(), side, uplo(), bindings::size_row(c), + bindings::size_column(c), alpha, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), beta, bindings::begin_value(c), + bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the hemm_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hemm. Its overload differs for +// +template< typename Side, typename MatrixA, typename MatrixB, typename MatrixC > +inline typename hemm_impl< typename bindings::value_type< + MatrixA >::type >::result_type +hemm( const Side side, const typename bindings::value_type< + MatrixA >::type alpha, const MatrixA& a, const MatrixB& b, + const typename bindings::value_type< MatrixA >::type beta, + MatrixC& c ) { + hemm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, alpha, a, b, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/her2k.hpp b/sdk/boost/numeric/bindings/blas/level3/her2k.hpp new file mode 100644 index 0000000..47596a5 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/her2k.hpp @@ -0,0 +1,334 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HER2K_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HER2K_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + cblas_ssyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + cblas_dsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, const float beta, + std::complex* c, const int ldc ) { + cblas_cher2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, const double beta, + std::complex* c, const int ldc ) { + cblas_zher2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, beta, + c, ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, const float beta, + std::complex* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCher2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, const double beta, + std::complex* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZher2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, const float alpha, + const float* a, const fortran_int_t lda, const float* b, + const fortran_int_t ldb, const float beta, float* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, const double alpha, + const double* a, const fortran_int_t lda, const double* b, + const fortran_int_t ldb, const double beta, double* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, const float beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHER2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void her2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, const double beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHER2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to her2k. +// +template< typename Value > +struct her2k_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC > + static result_type invoke( const value_type alpha, const MatrixA& a, + const MatrixB& b, const real_type beta, MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixC >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::her2k( order(), uplo(), trans(), + bindings::size_column(c), bindings::size_column(a), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), beta, + bindings::begin_value(c), bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the her2k_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for her2k. Its overload differs for +// +template< typename MatrixA, typename MatrixB, typename MatrixC > +inline typename her2k_impl< typename bindings::value_type< + MatrixA >::type >::result_type +her2k( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type beta, + MatrixC& c ) { + her2k_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, b, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/herk.hpp b/sdk/boost/numeric/bindings/blas/level3/herk.hpp new file mode 100644 index 0000000..51818f7 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/herk.hpp @@ -0,0 +1,308 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HERK_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_HERK_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float beta, float* c, const int ldc ) { + cblas_ssyrk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double beta, double* c, const int ldc ) { + cblas_dsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const std::complex* a, + const int lda, const float beta, std::complex* c, + const int ldc ) { + cblas_cherk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const std::complex* a, + const int lda, const double beta, std::complex* c, + const int ldc ) { + cblas_zherk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float beta, float* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double beta, double* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const std::complex* a, + const int lda, const float beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCherk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const std::complex* a, + const int lda, const double beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZherk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const float alpha, const float* a, + const fortran_int_t lda, const float beta, float* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const double alpha, const double* a, + const fortran_int_t lda, const double beta, double* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const float alpha, + const std::complex* a, const fortran_int_t lda, + const float beta, std::complex* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CHERK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void herk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const double alpha, + const std::complex* a, const fortran_int_t lda, + const double beta, std::complex* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZHERK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to herk. +// +template< typename Value > +struct herk_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixC > + static result_type invoke( const real_type alpha, const MatrixA& a, + const real_type beta, MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixC >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::herk( order(), uplo(), trans(), + bindings::size_column(c), bindings::size_column(a), alpha, + bindings::begin_value(a), bindings::stride_major(a), beta, + bindings::begin_value(c), bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the herk_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for herk. Its overload differs for +// +template< typename MatrixA, typename MatrixC > +inline typename herk_impl< typename bindings::value_type< + MatrixA >::type >::result_type +herk( const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type alpha, const MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type beta, MatrixC& c ) { + herk_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/symm.hpp b/sdk/boost/numeric/bindings/blas/level3/symm.hpp new file mode 100644 index 0000000..62b54f7 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/symm.hpp @@ -0,0 +1,336 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_SYMM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_SYMM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + cblas_ssymm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c, + ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + cblas_dsymm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, alpha, a, lda, b, ldb, beta, c, + ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_csymm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_zsymm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, m, n, &alpha, a, lda, b, ldb, &beta, + c, ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsymm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsymm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCsymm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const int m, + const int n, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZsymm( blas_option< Side >::value, blas_option< UpLo >::value, m, n, + alpha, a, lda, b, ldb, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const float alpha, const float* a, + const fortran_int_t lda, const float* b, const fortran_int_t ldb, + const float beta, float* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const double alpha, const double* a, + const fortran_int_t lda, const double* b, const fortran_int_t ldb, + const double beta, double* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CSYMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo > +inline void symm( const Order, const Side, const UpLo, const fortran_int_t m, + const fortran_int_t n, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZSYMM( &blas_option< Side >::value, &blas_option< UpLo >::value, &m, + &n, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to symm. +// +template< typename Value > +struct symm_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename MatrixB, + typename MatrixC > + static result_type invoke( const Side side, const value_type alpha, + const MatrixA& a, const MatrixB& b, const value_type beta, + MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::symm( order(), side, uplo(), bindings::size_row(c), + bindings::size_column(c), alpha, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), beta, bindings::begin_value(c), + bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the symm_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for symm. Its overload differs for +// +template< typename Side, typename MatrixA, typename MatrixB, typename MatrixC > +inline typename symm_impl< typename bindings::value_type< + MatrixA >::type >::result_type +symm( const Side side, const typename bindings::value_type< + MatrixA >::type alpha, const MatrixA& a, const MatrixB& b, + const typename bindings::value_type< MatrixA >::type beta, + MatrixC& c ) { + symm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, alpha, a, b, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/syr2k.hpp b/sdk/boost/numeric/bindings/blas/level3/syr2k.hpp new file mode 100644 index 0000000..89cf7d3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/syr2k.hpp @@ -0,0 +1,338 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_SYR2K_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_SYR2K_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + cblas_ssyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + cblas_dsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, b, ldb, beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_csyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, &beta, + c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_zsyr2k( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, &alpha, a, lda, b, ldb, &beta, + c, ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float* b, const int ldb, const float beta, float* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double* b, const int ldb, const double beta, double* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex* b, const int ldb, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZsyr2k( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, b, ldb, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, const float alpha, + const float* a, const fortran_int_t lda, const float* b, + const fortran_int_t ldb, const float beta, float* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, const double alpha, + const double* a, const fortran_int_t lda, const double* b, + const fortran_int_t ldb, const double beta, double* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, const std::complex beta, + std::complex* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syr2k( const Order, const UpLo, const Trans, + const fortran_int_t n, const fortran_int_t k, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, const std::complex beta, + std::complex* c, const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZSYR2K( &blas_option< UpLo >::value, &blas_option< Trans >::value, + &n, &k, &alpha, a, &lda, b, &ldb, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syr2k. +// +template< typename Value > +struct syr2k_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC > + static result_type invoke( const value_type alpha, const MatrixA& a, + const MatrixB& b, const value_type beta, MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixC >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::syr2k( order(), uplo(), trans(), + bindings::size_column(c), bindings::size_column(a), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), beta, + bindings::begin_value(c), bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the syr2k_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syr2k. Its overload differs for +// +template< typename MatrixA, typename MatrixB, typename MatrixC > +inline typename syr2k_impl< typename bindings::value_type< + MatrixA >::type >::result_type +syr2k( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const MatrixB& b, + const typename bindings::value_type< MatrixA >::type beta, + MatrixC& c ) { + syr2k_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, b, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/syrk.hpp b/sdk/boost/numeric/bindings/blas/level3/syrk.hpp new file mode 100644 index 0000000..d4806dd --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/syrk.hpp @@ -0,0 +1,315 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_SYRK_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_SYRK_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float beta, float* c, const int ldc ) { + cblas_ssyrk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double beta, double* c, const int ldc ) { + cblas_dsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_csyrk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, &alpha, a, lda, &beta, c, + ldc ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex beta, std::complex* c, + const int ldc ) { + cblas_zsyrk( cblas_option< Order >::value, cblas_option< UpLo >::value, + cblas_option< Trans >::value, n, k, &alpha, a, lda, &beta, c, + ldc ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const float alpha, const float* a, const int lda, + const float beta, float* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasSsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const double alpha, const double* a, const int lda, + const double beta, double* c, const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const int n, + const int k, const std::complex alpha, + const std::complex* a, const int lda, + const std::complex beta, std::complex* c, + const int ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZsyrk( blas_option< UpLo >::value, blas_option< Trans >::value, n, + k, alpha, a, lda, beta, c, ldc ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const float alpha, const float* a, + const fortran_int_t lda, const float beta, float* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_SSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const double alpha, const double* a, + const fortran_int_t lda, const double beta, double* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Trans > +inline void syrk( const Order, const UpLo, const Trans, const fortran_int_t n, + const fortran_int_t k, const std::complex alpha, + const std::complex* a, const fortran_int_t lda, + const std::complex beta, std::complex* c, + const fortran_int_t ldc ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZSYRK( &blas_option< UpLo >::value, &blas_option< Trans >::value, &n, + &k, &alpha, a, &lda, &beta, c, &ldc ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syrk. +// +template< typename Value > +struct syrk_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixC > + static result_type invoke( const value_type alpha, const MatrixA& a, + const value_type beta, MatrixC& c ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixC >::type uplo; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + detail::syrk( order(), uplo(), trans(), + bindings::size_column(c), bindings::size_column(a), alpha, + bindings::begin_value(a), bindings::stride_major(a), beta, + bindings::begin_value(c), bindings::stride_major(c) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the syrk_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syrk. Its overload differs for +// +template< typename MatrixA, typename MatrixC > +inline typename syrk_impl< typename bindings::value_type< + MatrixA >::type >::result_type +syrk( const typename bindings::value_type< MatrixA >::type alpha, + const MatrixA& a, const typename bindings::value_type< + MatrixA >::type beta, MatrixC& c ) { + syrk_impl< typename bindings::value_type< + MatrixA >::type >::invoke( alpha, a, beta, c ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/trmm.hpp b/sdk/boost/numeric/bindings/blas/level3/trmm.hpp new file mode 100644 index 0000000..48bc2b3 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/trmm.hpp @@ -0,0 +1,334 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_TRMM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_TRMM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const float alpha, + const float* a, const int lda, float* b, const int ldb ) { + cblas_strmm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const double alpha, + const double* a, const int lda, double* b, const int ldb ) { + cblas_dtrmm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const std::complex alpha, + const std::complex* a, const int lda, std::complex* b, + const int ldb ) { + cblas_ctrmm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, std::complex* b, const int ldb ) { + cblas_ztrmm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const float alpha, + const float* a, const int lda, float* b, const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStrmm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const double alpha, + const double* a, const int lda, double* b, const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtrmm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const std::complex alpha, + const std::complex* a, const int lda, std::complex* b, + const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtrmm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, std::complex* b, const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtrmm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const float alpha, const float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STRMM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const double alpha, const double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTRMM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTRMM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trmm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTRMM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trmm. +// +template< typename Value > +struct trmm_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename MatrixB > + static result_type invoke( const Side side, const value_type alpha, + const MatrixA& a, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type transa; + typedef typename result_of::uplo_tag< MatrixA, transa >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + detail::trmm( order(), side, uplo(), transa(), diag(), + bindings::size_row(b), bindings::size_column(b), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the trmm_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trmm. Its overload differs for +// +template< typename Side, typename MatrixA, typename MatrixB > +inline typename trmm_impl< typename bindings::value_type< + MatrixA >::type >::result_type +trmm( const Side side, const typename bindings::value_type< + MatrixA >::type alpha, const MatrixA& a, MatrixB& b ) { + trmm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, alpha, a, b ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/blas/level3/trsm.hpp b/sdk/boost/numeric/bindings/blas/level3/trsm.hpp new file mode 100644 index 0000000..6f91c34 --- /dev/null +++ b/sdk/boost/numeric/bindings/blas/level3/trsm.hpp @@ -0,0 +1,334 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_TRSM_HPP +#define BOOST_NUMERIC_BINDINGS_BLAS_LEVEL3_TRSM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The BLAS-backend is selected by defining a pre-processor variable, +// which can be one of +// * for CBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// * for CUBLAS, define BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// * netlib-compatible BLAS is the default +// +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +#include +#include +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace blas { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end BLAS-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_BLAS_CBLAS +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const float alpha, + const float* a, const int lda, float* b, const int ldb ) { + cblas_strsm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const double alpha, + const double* a, const int lda, double* b, const int ldb ) { + cblas_dtrsm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const std::complex alpha, + const std::complex* a, const int lda, std::complex* b, + const int ldb ) { + cblas_ctrsm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, std::complex* b, const int ldb ) { + cblas_ztrsm( cblas_option< Order >::value, cblas_option< Side >::value, + cblas_option< UpLo >::value, cblas_option< TransA >::value, + cblas_option< Diag >::value, m, n, &alpha, a, lda, b, ldb ); +} + +#elif defined BOOST_NUMERIC_BINDINGS_BLAS_CUBLAS +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const float alpha, + const float* a, const int lda, float* b, const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasStrsm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const double alpha, + const double* a, const int lda, double* b, const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasDtrsm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, const std::complex alpha, + const std::complex* a, const int lda, std::complex* b, + const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasCtrsm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * CUBLAS backend, and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const int m, const int n, + const std::complex alpha, const std::complex* a, + const int lda, std::complex* b, const int ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + cublasZtrsm( blas_option< Side >::value, blas_option< UpLo >::value, + blas_option< TransA >::value, blas_option< Diag >::value, m, n, + alpha, a, lda, b, ldb ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * float value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const float alpha, const float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_STRSM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * double value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const double alpha, const double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_DTRSM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_CTRSM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +// +// Overloaded function for dispatching to +// * netlib-compatible BLAS backend (the default), and +// * complex value-type. +// +template< typename Order, typename Side, typename UpLo, typename TransA, + typename Diag > +inline void trsm( const Order, const Side, const UpLo, const TransA, + const Diag, const fortran_int_t m, const fortran_int_t n, + const std::complex alpha, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + BLAS_ZTRSM( &blas_option< Side >::value, &blas_option< UpLo >::value, + &blas_option< TransA >::value, &blas_option< Diag >::value, &m, + &n, &alpha, a, &lda, b, &ldb ); +} + +#endif + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trsm. +// +template< typename Value > +struct trsm_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + typedef void result_type; + + // + // Static member function that + // * Deduces the required arguments for dispatching to BLAS, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename MatrixB > + static result_type invoke( const Side side, const value_type alpha, + const MatrixA& a, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type transa; + typedef typename result_of::uplo_tag< MatrixA, transa >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::has_linear_array< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + detail::trsm( order(), side, uplo(), transa(), diag(), + bindings::size_row(b), bindings::size_column(b), alpha, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b) ); + } +}; + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. Calls +// to these functions are passed to the trsm_impl classes. In the +// documentation, the const-overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trsm. Its overload differs for +// +template< typename Side, typename MatrixA, typename MatrixB > +inline typename trsm_impl< typename bindings::value_type< + MatrixA >::type >::result_type +trsm( const Side side, const typename bindings::value_type< + MatrixA >::type alpha, const MatrixA& a, MatrixB& b ) { + trsm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, alpha, a, b ); +} + +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/boost/array.hpp b/sdk/boost/numeric/bindings/boost/array.hpp new file mode 100644 index 0000000..22f2c8d --- /dev/null +++ b/sdk/boost/numeric/bindings/boost/array.hpp @@ -0,0 +1,47 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BOOST_ARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_BOOST_ARRAY_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, std::size_t N, typename Id, typename Enable > +struct adaptor< boost::array, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, mpl::int_ >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static value_type* begin_value( Id& t ) { + return t.begin(); + } + + static value_type* end_value( Id& t ) { + return t.end(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/boost/multi_array.hpp b/sdk/boost/numeric/bindings/boost/multi_array.hpp new file mode 100644 index 0000000..5dd0c8b --- /dev/null +++ b/sdk/boost/numeric/bindings/boost/multi_array.hpp @@ -0,0 +1,87 @@ +// +// Copyright (c) 2010 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_BOOST_MULTI_ARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_BOOST_MULTI_ARRAY_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Map, typename AddressingIndex > +struct multi_array_dim_inserter { + + typedef typename mpl::insert< + typename mpl::insert< + Map, + mpl::pair< tag::size_type< AddressingIndex::value >, std::ptrdiff_t > + >::type, + mpl::pair< tag::stride_type< AddressingIndex::value >, std::ptrdiff_t > + >::type type; + +}; + +template< typename T, std::size_t Dim, typename Alloc, typename Id, typename Enable > +struct adaptor< boost::multi_array, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::tensor< Dim > >, + mpl::pair< tag::data_order, tag::row_major >, + mpl::pair< tag::data_structure, tag::linear_array > + > basic_map; + typedef typename mpl::fold< + mpl::range_c< std::size_t, 1, Dim+1 >, + basic_map, + multi_array_dim_inserter< + mpl::_1, + mpl::_2 + > + >::type property_map; + + // Sizes are only reachable if Addressing Index <= Dim, otherwise + // the default (1) will be returned + static std::ptrdiff_t size1( const Id& id ) { + return id.shape()[0]; + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.shape()[1]; + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.strides()[0]; + } + + // Only reachable if dimension D is sufficient + static std::ptrdiff_t stride2( const Id& id ) { + return id.strides()[1]; + } + + static value_type* begin_value( Id& id ) { + return id.data(); + } + + static value_type* end_value( Id& id ) { + return id.data()+id.num_elements(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/column.hpp b/sdk/boost/numeric/bindings/column.hpp new file mode 100644 index 0000000..f636006 --- /dev/null +++ b/sdk/boost/numeric/bindings/column.hpp @@ -0,0 +1,96 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_COLUMN_HPP +#define BOOST_NUMERIC_BINDINGS_COLUMN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T > +struct column_wrapper: + adaptable_type< column_wrapper >, + reference_wrapper { + + column_wrapper( T& t, std::size_t index ): + reference_wrapper(t), + m_index( index ) {} + + std::size_t m_index; +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< column_wrapper, Id, Enable > { + + typedef typename bindings::value_type< T>::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, typename result_of::size1::type >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, typename result_of::stride1::type > + > property_map; + + static typename result_of::size1::type size1( const Id& id ) { + return bindings::size1( id.get() ); + } + + static typename result_of::begin_value< T >::type begin_value( Id& id ) { + return bindings::begin_value( id.get() ) + + offset( id.get(), 0, id.m_index ); + } + + static typename result_of::end_value< T >::type end_value( Id& id ) { + return bindings::begin_value( id.get() ) + + offset( id.get(), size1(id), id.m_index ); + } + + static typename result_of::stride1::type stride1( const Id& id ) { + return bindings::stride1( id.get() ); + } + +}; + + +} // namespace detail + +namespace result_of { + +template< typename T > +struct column { + typedef detail::column_wrapper type; +}; + +} + +template< typename T > +detail::column_wrapper const column( T& underlying, std::size_t index ) { + return detail::column_wrapper( underlying, index ); +} + +template< typename T > +detail::column_wrapper const column( const T& underlying, std::size_t index ) { + return detail::column_wrapper( underlying, index ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/conj.hpp b/sdk/boost/numeric/bindings/conj.hpp new file mode 100644 index 0000000..888c70b --- /dev/null +++ b/sdk/boost/numeric/bindings/conj.hpp @@ -0,0 +1,48 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_CONJ_HPP +#define BOOST_NUMERIC_BINDINGS_CONJ_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +namespace result_of { + +template< typename T > +struct conj { + typedef detail::trans_wrapper< + T, + typename mpl::if_< + detail::is_same_at< T, tag::value_transform, tag::conjugate >, + mpl::pair< tag::value_transform, mpl::void_ >, + mpl::pair< tag::value_transform, tag::conjugate > + >::type + > type; +}; + +} + +template< typename T > +typename result_of::conj< T >::type const conj( T& t ) { + return typename result_of::conj< T >::type( t ); +} + +template< typename T > +typename result_of::conj< const T >::type const conj( const T& t ) { + return typename result_of::conj< const T >::type( t ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/data_order.hpp b/sdk/boost/numeric/bindings/data_order.hpp new file mode 100644 index 0000000..ad3eb89 --- /dev/null +++ b/sdk/boost/numeric/bindings/data_order.hpp @@ -0,0 +1,44 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DATA_ORDER_HPP +#define BOOST_NUMERIC_BINDINGS_DATA_ORDER_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T, typename Enable = void > +struct data_order {}; + +template< typename T > +struct data_order< T, typename boost::enable_if< is_column_major >::type > { + typedef tag::column_major type; +}; + +template< typename T > +struct data_order< T, typename boost::enable_if< is_row_major >::type > { + typedef tag::row_major type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::data_order::type data_order( const T& ) { + return typename result_of::data_order::type(); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/data_side.hpp b/sdk/boost/numeric/bindings/data_side.hpp new file mode 100644 index 0000000..babdcfd --- /dev/null +++ b/sdk/boost/numeric/bindings/data_side.hpp @@ -0,0 +1,35 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DATA_SIDE_HPP +#define BOOST_NUMERIC_BINDINGS_DATA_SIDE_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct data_side { + typedef typename detail::property_at< T, tag::data_side >::type type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::data_side::type data_side( const T& ) { + return result_of::data_side::type(); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/adaptable_type.hpp b/sdk/boost/numeric/bindings/detail/adaptable_type.hpp new file mode 100644 index 0000000..a03281a --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/adaptable_type.hpp @@ -0,0 +1,43 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_ADAPTABLE_TYPE_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_ADAPTABLE_TYPE_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Derived > +struct adaptable_type { + + inline + Derived& derived() { + return *static_cast(this); + } + + inline + Derived const& derived() const { + return *static_cast(this); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +template< typename T > +std::ostream& operator<<( std::ostream& os, + boost::numeric::bindings::detail::adaptable_type const& object ); + +#endif diff --git a/sdk/boost/numeric/bindings/detail/adaptor.hpp b/sdk/boost/numeric/bindings/detail/adaptor.hpp new file mode 100644 index 0000000..1577514 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/adaptor.hpp @@ -0,0 +1,51 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_ADAPTOR_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_ADAPTOR_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable = void > +struct adaptor { + typedef mpl::map< + mpl::pair< tag::value_type, void > + > property_map; +}; + +template< typename T > +struct is_adaptable: is_numeric< typename mpl::at< + typename adaptor< typename boost::remove_const::type, T >::property_map, + tag::value_type >::type > {}; + +template< typename T, typename Enable = void > +struct adaptor_access {}; + +template< typename T > +struct adaptor_access< T, typename boost::enable_if< is_adaptable >::type >: + adaptor< typename boost::remove_const::type, T > {}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/detail/array.hpp b/sdk/boost/numeric/bindings/detail/array.hpp new file mode 100644 index 0000000..d5a7070 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/array.hpp @@ -0,0 +1,127 @@ +// +// Copyright (c) 2003 Kresimir Fresl +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_ARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_ARRAY_HPP + +#include +#include +#include + + +/* + very simple dynamic array class which is used in `higher level' + bindings functions for pivot and work arrays + + Namely, there are (at least) two versions of all bindings functions + where called LAPACK function expects work and/or pivot array, e.g. + + `lower' level (user should provide work and pivot arrays): + int sysv (SymmA& a, IVec& i, MatrB& b, Work& w); + + `higher' level (with `internal' work and pivot arrays): + int sysv (SymmA& a, MatrB& b); + + Probably you ask why I didn't use std::vector. There are two reasons. + First is efficiency -- std::vector's constructor initialises vector + elements. Second is consistency. LAPACK functions use `info' parameter + as an error indicator. On the other hand, std::vector's allocator can + throw an exception if memory allocation fails. detail::array's + constructor uses `new (nothrow)' which returns 0 if allocation fails. + So I can check whether array::storage == 0 and return appropriate error + in `info'.*/ + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template +class array : private noncopyable { +public: + typedef std::ptrdiff_t size_type ; + + array (size_type n) { + stg = new (std::nothrow) T[n]; + sz = (stg != 0) ? n : 0; + } + + ~array() { + delete[] stg; + } + + size_type size() const { + return sz; + } + + bool valid() const { + return stg != 0; + } + + void resize (int n) { + delete[] stg; + stg = new (std::nothrow) T[n]; + sz = (stg != 0) ? n : 0; + } + + T* storage() { + return stg; + } + + T const* storage() const { + return stg; + } + + T& operator[] (int i) { + return stg[i]; + } + + T const& operator[] (int i) const { + return stg[i]; + } + +private: + size_type sz; + T* stg; +}; + + +template< typename T, typename Id, typename Enable > +struct adaptor< array< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& t ) { + return t.size(); + } + + static value_type* begin_value( Id& t ) { + return t.storage(); + } + + static value_type* end_value( Id& t ) { + return t.storage() + t.size(); + } + +}; + + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/basic_unwrapper.hpp b/sdk/boost/numeric/bindings/detail/basic_unwrapper.hpp new file mode 100644 index 0000000..115427f --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/basic_unwrapper.hpp @@ -0,0 +1,56 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_BASIC_UNWRAPPER_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_BASIC_UNWRAPPER_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id > +struct basic_unwrapper { + + static typename result_of::size1< T >::type size1( const Id& id ) { + return bindings::size1( id.get() ); + } + + static typename result_of::size2< T >::type size2( const Id& id ) { + return bindings::size2( id.get() ); + } + + static typename result_of::stride1< T >::type stride1( const Id& id ) { + return bindings::stride1( id.get() ); + } + + static typename result_of::stride2< T >::type stride2( const Id& id ) { + return bindings::stride2( id.get() ); + } + + static typename result_of::begin_value< T >::type begin_value( Id& id ) { + return bindings::begin_value( id.get() ); + } + + static typename result_of::end_value< T >::type end_value( Id& id ) { + return bindings::end_value( id.get() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/basic_wrapper.hpp b/sdk/boost/numeric/bindings/detail/basic_wrapper.hpp new file mode 100644 index 0000000..53b9dc0 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/basic_wrapper.hpp @@ -0,0 +1,41 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_BASIC_WRAPPER_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_BASIC_WRAPPER_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename P1 = mpl::void_, typename P2 = mpl::void_, + typename P3 = mpl::void_, typename P4 = mpl::void_ > +struct basic_wrapper: reference_wrapper { + basic_wrapper( T& t ): reference_wrapper( t ) {} +}; + +template< typename T, typename P1, typename P2, typename P3, typename P4, + typename Id, typename Enable > +struct adaptor< basic_wrapper, Id, Enable >: + basic_unwrapper< T, Id > { + + typedef typename property_insert< T, P1, P2, P3, P4 >::type property_map; + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/complex_utils.hpp b/sdk/boost/numeric/bindings/detail/complex_utils.hpp new file mode 100644 index 0000000..ad6cf13 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/complex_utils.hpp @@ -0,0 +1,182 @@ +// +// Copyright (c) 2003 Kresimir Fresl +// Copyright (c) 2010 Thomas Klimpel +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_COMPLEX_UTILS_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_COMPLEX_UTILS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +namespace detail { + +#ifdef BOOST_NUMERIC_BINDINGS_BY_THE_BOOK +template +void inshuffle(It it, std::size_t n) { + if (n==0) return; + for (std::size_t i = 0; 2*i < n; ++i) { + std::size_t k = 2*i + 1; + while (2*k <= n) k *= 2; + typename std::iterator_traits::value_type tmp = it[n+i]; + it[n+i] = it[k-1]; + while (k % 2 == 0) { + it[k-1] = it[(k/2)-1]; + k /= 2; + } + it[k-1] = tmp; + } + std::size_t kmin = 1; + while (2*kmin <= n) kmin *= 2; + for (std::size_t i = 0; 4*i+1 < n; ++i) { + std::size_t k = 2*i + 1; + while (2*k <= n) k *= 2; + std::size_t k1 = 2*(i+1) + 1; + while (2*k1 <= n) k1 *= 2; + if (k > k1) { + if (k1 < kmin) { + kmin = k1; + inshuffle(it+n, i+1); + } + else + inshuffle(it+n+1, i); + } + } + return inshuffle(it+n+(n%2), n/2); +} +#else +template +void inshuffle(It it, std::size_t n) { + while (n > 0) { + std::size_t kmin = 1; + while (kmin <= n) + kmin *= 2; + { + std::size_t kk = kmin/2; + It itn = it + n; + for (std::size_t i = 0, s = (n+1)/2; i < s; ++i) { + std::size_t k = (2*i+1)*kk; + while (k > n) { + k /= 2; + kk /= 2; + } + // apply the cyclic permutation + typename std::iterator_traits::value_type tmp = itn[i]; + itn[i] = it[k-1]; + while (k % 2 == 0) { + it[k-1] = it[(k/2)-1]; + k /= 2; + } + it[k-1] = tmp; + } + } + // the optimized computation of k fails for n=2, + // so skip the 'normalization' loop when possible + if (n > 3) { + std::size_t kk = kmin/4; + for (std::size_t i = 1; 4*i < n+3; ++i) { + std::size_t k = (2*i+1)*kk; + if (k > n) { + kk /= 2; + if (k < kmin) { + kmin = k; + // if kmin is updated, do an in-shuffle + inshuffle(it+n, i); + } + else + // otherwise do an out-shuffle + inshuffle(it+n+1, i-1); + } + } + } + // implement the tail recursion as an iteration + it += n+(n%2); + n /= 2; + } +} +#endif + +// Reorders a real array followed by an imaginary array to a true complex array +// where real and imaginary part of each number directly follow each other. +template +typename boost::enable_if< is_complex< typename bindings::value_type< VectorW >::type >, void >::type +interlace (VectorW& w) { + typedef typename bindings::value_type< VectorW >::type value_type; + typedef typename bindings::remove_imaginary< value_type >::type real_type; + value_type* pw = bindings::begin_value(w); + std::ptrdiff_t n = bindings::end_value(w) - pw; + if (n < 2) return; + inshuffle(reinterpret_cast (pw)+1, n-1); +} + +} // namespace detail + +namespace result_of { + +template< typename VectorW > +struct real_part_view { + typedef typename bindings::result_of::vector_view< typename + bindings::remove_imaginary< typename + bindings::value_type< VectorW >::type + >::type >::type type; +}; + +template< typename VectorW > +struct imag_part_view { + typedef typename bindings::result_of::vector_view< typename + bindings::remove_imaginary< typename + bindings::value_type< VectorW >::type + >::type >::type type; +}; + +} // namespace result_of + +namespace detail { + +// Creates a real vector_view to the first half of the complex array, +// which is intended to be filled by the real part +template +typename boost::enable_if< is_complex< typename bindings::value_type< VectorW >::type >, + typename result_of::real_part_view< VectorW >::type const >::type +real_part_view (VectorW& w) { + typedef typename bindings::value_type< VectorW >::type value_type; + typedef typename bindings::remove_imaginary< value_type >::type real_type; + value_type* pw = bindings::begin_value(w); + std::ptrdiff_t n = bindings::end_value(w) - pw; + return bindings::vector_view(reinterpret_cast (pw), n); +} + +// Creates a real vector_view to the second half of the complex array, +// which is intended to be filled by the imaginary part +template +typename boost::enable_if< is_complex< typename bindings::value_type< VectorW >::type >, + typename result_of::imag_part_view< VectorW >::type const >::type +imag_part_view (VectorW& w) { + typedef typename bindings::value_type< VectorW >::type value_type; + typedef typename bindings::remove_imaginary< value_type >::type real_type; + value_type* pw = bindings::begin_value(w); + std::ptrdiff_t n = bindings::end_value(w) - pw; + return bindings::vector_view(reinterpret_cast (pw)+n, n); +} + +} // namespace detail + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/config/fortran.hpp b/sdk/boost/numeric/bindings/detail/config/fortran.hpp new file mode 100644 index 0000000..3307858 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/config/fortran.hpp @@ -0,0 +1,88 @@ +// +// Copyright (C) 2002, 2003 Si-Lab b.v.b.a., Toon Knapen and Kresimir Fresl +// 2010 Thomas Klimpel +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_CONFIG_FORTRAN_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_CONFIG_FORTRAN_HPP + +#if defined(BIND_FORTRAN_LOWERCASE_UNDERSCORE) || defined(BIND_FORTRAN_LOWERCASE) || defined(BIND_FORTRAN_UPPERCASE_UNDERSCORE) || defined(BIND_FORTRAN_UPPERCASE) +// Allow manual override of the defaults, e.g. if you want to use a fortran +// lib compiled with gcc from MSVC +#else + +// We have no chance of determining the conventions for linking C with Fortran +// here, because they only depend on the fortran compiler and it's command line +// switches, but not on the C++ compiler which compiles these lines. + +// We default to lowercase underscore, because this is much more common than +// the other option. (The previous automatic configuration only selected the +// other option in case of "defined(__IBMCPP__) || defined(_MSC_VER)".) +#define BIND_FORTRAN_LOWERCASE_UNDERSCORE + +#endif + +// Next we define macro's to convert our symbols to +// the current convention +#if defined(BIND_FORTRAN_LOWERCASE_UNDERSCORE) +#define FORTRAN_ID( id ) id##_ +#define FORTRAN_ID2( id, ID2 ) id##_ +#elif defined(BIND_FORTRAN_LOWERCASE) +#define FORTRAN_ID( id ) id +#define FORTRAN_ID2( id, ID2 ) id +#elif defined(BIND_FORTRAN_UPPERCASE_UNDERSCORE) +#define FORTRAN_ID2( id, ID2 ) ID2##_ +#elif defined(BIND_FORTRAN_UPPERCASE) +#define FORTRAN_ID2( id, ID2 ) ID2 +#else +#error do not know how to bind to fortran calling convention +#endif + + +#ifdef BIND_FORTRAN_F2C_RETURN_CONVENTIONS +// "g77" or clapack or "gfortran -ff2c" +#define BIND_FORTRAN_RETURN_REAL_DOUBLE +#define BIND_FORTRAN_RETURN_COMPLEX_FIRST_ARG +#elif BIND_FORTRAN_MKL_RETURN_CONVENTIONS +// mkl +#define BIND_FORTRAN_RETURN_COMPLEX_FIRST_ARG +#elif BIND_FORTRAN_OSX_RETURN_CONVENTIONS +// OS X +#define BIND_FORTRAN_RETURN_COMPLEX_LAST_ARG +#else +// "g77 -fno-f2c" or "gfortran" +#endif + + +// "g77" or "gfortran" or mkl_intel_lp64 +//#undef BIND_FORTRAN_INTEGER_8 +// clapack or "gfortran -fdefault-integer-8" or mkl_intel_ilp64 +//#define BIND_FORTRAN_INTEGER_8 + +// Most fortran compilers use fortran_int_t := int by default, so we follow +// this default, even so f2c (=clapack) uses "typedef long int integer;" +#ifndef BIND_FORTRAN_INTEGER_8 +typedef int fortran_int_t; +#else +typedef std::ptrdiff_t fortran_int_t; +#endif + +// Looks like fortran_int_t and fortran_bool_t should be identical, the unsigned is +// required so overloads can distinguish between fortran_bool_t and fortran_int_t. +#ifndef BIND_FORTRAN_INTEGER_8 +typedef unsigned int fortran_bool_t; +#else +typedef std::size_t fortran_bool_t; +#endif + +// This definition of external_fp is identical to the definition of L_fp from +// f2c, and it seems to work more or less. These functions return fortran_bool_t, +// but they don't all take the same type of arguments. A reinterpret_cast will +// probably work for most compilers to extend the allowed function signatures. +typedef fortran_bool_t (*external_fp)(...); + +#endif // BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H diff --git a/sdk/boost/numeric/bindings/detail/convert_to.hpp b/sdk/boost/numeric/bindings/detail/convert_to.hpp new file mode 100644 index 0000000..6a6ee10 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/convert_to.hpp @@ -0,0 +1,25 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_CONVERT_TO_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_CONVERT_TO_HPP + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Target, typename Source > +struct convert_to {}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/copy_const.hpp b/sdk/boost/numeric/bindings/detail/copy_const.hpp new file mode 100644 index 0000000..9a04390 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/copy_const.hpp @@ -0,0 +1,32 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_COPY_CONST_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_COPY_CONST_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Source, typename Target > +struct copy_const { + typedef typename mpl::if_< is_const, + typename add_const::type, Target >::type type; +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/generate_functions.hpp b/sdk/boost/numeric/bindings/detail/generate_functions.hpp new file mode 100644 index 0000000..2208ef7 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/generate_functions.hpp @@ -0,0 +1,48 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_GENERATE_FUNCTIONS_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_GENERATE_FUNCTIONS_HPP + +#include +#include + +// +// Macro used to generate convenience functions +// + +#define GENERATE_FUNCTIONS( function_name, suffix, tag ) \ +\ +namespace result_of {\ +\ +template< typename T > \ +struct BOOST_PP_CAT( function_name, suffix ) { \ + typedef typename detail::\ + BOOST_PP_CAT( function_name, _impl ) \ + ::result_type type; \ +}; \ +\ +}\ +\ +template< typename T >\ +typename result_of:: BOOST_PP_CAT( function_name, suffix )::type \ +BOOST_PP_CAT( function_name, suffix )( T& t ) {\ + return detail:: \ + BOOST_PP_CAT( function_name, _impl ) \ + ::invoke( t );\ +}\ +\ +template< typename T >\ +typename result_of:: BOOST_PP_CAT( function_name, suffix )::type \ +BOOST_PP_CAT( function_name, suffix )( const T& t ) {\ + return detail:: \ + BOOST_PP_CAT( function_name, _impl ) \ + ::invoke( t );\ +} + +#endif diff --git a/sdk/boost/numeric/bindings/detail/get.hpp b/sdk/boost/numeric/bindings/detail/get.hpp new file mode 100644 index 0000000..035bccb --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/get.hpp @@ -0,0 +1,96 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_GET_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_GET_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Key > +struct get_dispatch {}; + +#define GENERATE_GET( z, which, unused ) \ +template<> \ +struct get_dispatch< tag::size_type > { \ + template< typename T > \ + static std::ptrdiff_t invoke( const T& t ) { \ + return detail::adaptor_access:: \ + BOOST_PP_CAT( size, which )( t ); \ + } \ +};\ +\ +template<> \ +struct get_dispatch< tag::stride_type > { \ + template< typename T > \ + static std::ptrdiff_t invoke( const T& t ) { \ + return detail::adaptor_access:: \ + BOOST_PP_CAT( stride, which )( t ); \ + } \ +};\ +\ +template<> \ +struct get_dispatch< tag::bandwidth_type > { \ + template< typename T > \ + static std::ptrdiff_t invoke( const T& t ) { \ + return detail::adaptor_access:: \ + BOOST_PP_CAT( bandwidth, which )( t ); \ + } \ +}; + +BOOST_PP_REPEAT_FROM_TO(1,3,GENERATE_GET,~) + +template< typename T, typename Key, typename Enable = void > +struct get_impl {}; + +template< typename T, typename Key > +struct get_impl< T, Key, typename boost::enable_if< + is_same_at< T, Key, std::ptrdiff_t > >::type > { + + typedef std::ptrdiff_t result_type; + + static std::ptrdiff_t invoke( const T& t ) { + return get_dispatch::invoke( t ); + } + +}; + +template< typename T, typename Key > +struct get_impl< T, Key, typename boost::enable_if< + mpl::not_< is_same_at< T, Key, std::ptrdiff_t > > >::type > { + + typedef typename property_at< T, Key >::type result_type; + + static result_type invoke( const T& ) { + return result_type(); + } + +}; + +template< typename T, typename Key > +struct result_of_get { + typedef typename get_impl< T, Key >::result_type type; +}; + +template< typename Key, typename T > +typename result_of_get< T, Key >::type get( const T& t ) { + return get_impl< T, Key >::invoke( t ); +} + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/if_left.hpp b/sdk/boost/numeric/bindings/detail/if_left.hpp new file mode 100644 index 0000000..afdb74e --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/if_left.hpp @@ -0,0 +1,53 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_IF_LEFT_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_IF_LEFT_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Side, typename Left, typename Right > +struct if_left_impl { + + typedef Right result_type; + + static result_type invoke( Left, Right right ) { + return right; + } + +}; + +template< typename Left, typename Right > +struct if_left_impl< tag::left, Left, Right > { + + typedef Left result_type; + + static result_type invoke( Left left, Right ) { + return left; + } + +}; + +// by-value +template< typename Side, typename Left, typename Right > +typename if_left_impl< Side, const Left, const Right >::result_type +if_left( const Side, const Left left, const Right right ) { + return if_left_impl< Side, const Left, const Right >::invoke( left, right ); +} + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/if_row_major.hpp b/sdk/boost/numeric/bindings/detail/if_row_major.hpp new file mode 100644 index 0000000..00d4fe6 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/if_row_major.hpp @@ -0,0 +1,34 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_IF_ROW_MAJOR_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_IF_ROW_MAJOR_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Order, typename True, typename False > +struct if_row_major { + typedef False type; +}; + +template< typename True, typename False > +struct if_row_major< tag::row_major, True, False > { + typedef True type; +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/linear_iterator.hpp b/sdk/boost/numeric/bindings/detail/linear_iterator.hpp new file mode 100644 index 0000000..4b1cb1e --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/linear_iterator.hpp @@ -0,0 +1,89 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_LINEAR_ITERATOR_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_LINEAR_ITERATOR_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename StrideType > +class linear_iterator: public boost::iterator_adaptor< + linear_iterator, + T*, use_default, random_access_traversal_tag > { +public: + + typedef mpl::int_ stride_type; + + linear_iterator(): + linear_iterator::iterator_adaptor_(0) {} + + explicit linear_iterator( T* p, StrideType ignore ): + linear_iterator::iterator_adaptor_(p) {} + +private: + friend class boost::iterator_core_access; + + void advance( int n ) { + (this->base_reference()) += n * stride_type::value; + } + + void decrement() { + (this->base_reference()) -= stride_type::value; + } + + void increment() { + (this->base_reference()) += stride_type::value; + } + +}; + +template< typename T > +class linear_iterator< T, std::ptrdiff_t >: public boost::iterator_adaptor< + linear_iterator< T, std::ptrdiff_t >, + T*, use_default, random_access_traversal_tag > { +public: + + typedef std::ptrdiff_t stride_type; + + linear_iterator(): + linear_iterator::iterator_adaptor_(0), + m_stride(0) {} + + explicit linear_iterator( T* p, std::ptrdiff_t stride ): + linear_iterator::iterator_adaptor_(p), + m_stride( stride ) {} + +private: + friend class boost::iterator_core_access; + + void advance( int n ) { + (this->base_reference()) += n * m_stride; + } + + void decrement() { + (this->base_reference()) -= m_stride; + } + + void increment() { + (this->base_reference()) += m_stride; + } + + std::ptrdiff_t m_stride; +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/offset.hpp b/sdk/boost/numeric/bindings/detail/offset.hpp new file mode 100644 index 0000000..e60fd5b --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/offset.hpp @@ -0,0 +1,72 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_OFFSET_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_OFFSET_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Enable = void > +struct offset_impl {}; + +template< typename T > +struct offset_impl< T, typename boost::enable_if< has_linear_array< T > >::type > { + + static std::ptrdiff_t invoke( const T& t, std::ptrdiff_t i1 ) { + return i1 * bindings::stride1( t ); + } + + static std::ptrdiff_t invoke( const T& t, std::ptrdiff_t i1, std::ptrdiff_t i2 ) { + return i1 * bindings::stride1( t ) + + i2 * bindings::stride2( t ); + } + +}; + +template< typename T > +struct offset_impl< T, + typename boost::enable_if< + mpl::and_< + has_band_array< T >, + is_column_major< T > + > + >::type > { + + static std::ptrdiff_t invoke( const T& t, std::ptrdiff_t i1, std::ptrdiff_t i2 ) { + return i1 * bindings::stride1( t ) + + i2 * (bindings::stride2( t )-1); + } + +}; + +template< typename T > +std::ptrdiff_t offset( const T& t, std::ptrdiff_t i1 ) { + return offset_impl< T >::invoke( t, i1 ); +} + +template< typename T > +std::ptrdiff_t offset( const T& t, std::ptrdiff_t i1, std::ptrdiff_t i2 ) { + return offset_impl< T >::invoke( t, i1, i2 ); +} + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/pod.hpp b/sdk/boost/numeric/bindings/detail/pod.hpp new file mode 100644 index 0000000..3eeb4a6 --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/pod.hpp @@ -0,0 +1,90 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_POD_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_POD_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id > +struct adaptor< T, Id, typename boost::enable_if< is_numeric >::type > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::scalar >, + mpl::pair< tag::size_type<1>, mpl::int_<1> >, + mpl::pair< tag::data_structure, tag::linear_array > + > property_map; + + static value_type* begin_value( Id& t ) { + return &t; + } + +}; + +template< typename T, std::size_t N, typename Id > +struct adaptor< T[N], Id, typename boost::enable_if< is_numeric >::type > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, mpl::int_ >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static value_type* begin_value( Id& t ) { + return &t[0]; + } + + static value_type* end_value( Id& t ) { + return &t[N]; + } + +}; + +template< typename T, std::size_t M, std::size_t N, typename Id > +struct adaptor< T[M][N], Id, typename boost::enable_if< is_numeric >::type > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, mpl::int_ >, + mpl::pair< tag::size_type<2>, mpl::int_ >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, tag::row_major >, + mpl::pair< tag::stride_type<1>, mpl::int_ >, + mpl::pair< tag::stride_type<2>, tag::contiguous > + > property_map; + + static value_type* begin_value( Id& t ) { + return &t[0][0]; + } + + static value_type* end_value( Id& t ) { + return &t[M][N]; + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/detail/property_map.hpp b/sdk/boost/numeric/bindings/detail/property_map.hpp new file mode 100644 index 0000000..69dc1cd --- /dev/null +++ b/sdk/boost/numeric/bindings/detail/property_map.hpp @@ -0,0 +1,73 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DETAIL_PROPERTY_MAP_HPP +#define BOOST_NUMERIC_BINDINGS_DETAIL_PROPERTY_MAP_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Key > +struct property_has_key: mpl::has_key< typename adaptor_access::property_map, Key > {}; + +template< typename T, typename Key > +struct property_at { + typedef typename mpl::at< typename adaptor_access::property_map, Key >::type type; +}; + +template< typename T > +struct property_map_of { + typedef typename adaptor_access::property_map type; +}; + + +template< typename T, typename Key, typename Value > +struct is_same_at: is_same< typename property_at< T, Key >::type, Value > {}; + +// +// Meta-function to insert multiple pairs into a map by using fold. Using the +// provided mpl::insert can (only) insert elements in a map one-by-one. +// +template< typename T, + typename P1 = mpl::na, typename P2 = mpl::na, typename P3 = mpl::na, + typename P4 = mpl::na, typename P5 = mpl::na, typename P6 = mpl::na, + typename P7 = mpl::na, typename P8 = mpl::na, typename P9 = mpl::na, + typename P10 = mpl::na > +struct property_insert { + + typedef mpl::vector< P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > pair_vector; + typedef typename property_map_of< T >::type properties; + + typedef typename mpl::fold< + pair_vector, + properties, + mpl::if_< + is_same< mpl::_2, mpl::void_ >, + mpl::_1, + mpl::insert< mpl::_1, mpl::_2 > + > + >::type type; + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/diag_tag.hpp b/sdk/boost/numeric/bindings/diag_tag.hpp new file mode 100644 index 0000000..e3138e5 --- /dev/null +++ b/sdk/boost/numeric/bindings/diag_tag.hpp @@ -0,0 +1,56 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_DIAG_TAG_HPP +#define BOOST_NUMERIC_BINDINGS_DIAG_TAG_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +namespace detail { + +template< typename T > +struct diag_tag_impl { + typedef tag::non_unit type; +}; + +template<> +struct diag_tag_impl< tag::unit_triangular > { + typedef tag::unit type; +}; + +} // namespace detail + +namespace result_of { + +template< typename T > +struct diag_tag { + typedef typename detail::diag_tag_impl< + typename detail::property_at< T, tag::matrix_type >::type + >::type type; +}; + +} // namespace result_of + +// +// diag_tag will output tags that are compatible with BLAS and LAPACK +// +template< typename T, typename Order > +typename result_of::diag_tag< T >::type diag_tag( const T& t ) { + return result_of::diag_tag< T >::type(); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/eigen/matrix.hpp b/sdk/boost/numeric/bindings/eigen/matrix.hpp new file mode 100644 index 0000000..0248fcd --- /dev/null +++ b/sdk/boost/numeric/bindings/eigen/matrix.hpp @@ -0,0 +1,92 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_EIGEN_MATRIX_HPP +#define BOOST_NUMERIC_BINDINGS_EIGEN_MATRIX_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< int Value > +struct eigen_size_type { + typedef typename mpl::if_< + mpl::bool_< Value == Eigen::Dynamic >, + std::ptrdiff_t, + mpl::int_ + >::type type; +}; + +template< int Value > +struct eigen_data_order { + typedef typename mpl::if_< + mpl::bool_< Value & Eigen::RowMajorBit >, + tag::row_major, + tag::column_major + >::type type; +}; + +template< typename T, int Rows, int Cols, int Options, + typename Id, typename Enable > +struct adaptor< Eigen::Matrix< T, Rows, Cols, Options >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename eigen_size_type< Rows >::type size_type1; + typedef typename eigen_size_type< Cols >::type size_type2; + typedef typename eigen_data_order< Options >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, size_type1 >, + mpl::pair< tag::size_type<2>, size_type2 >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::stride_type<1>, + typename if_row_major< data_order, size_type2, tag::contiguous >::type >, + mpl::pair< tag::stride_type<2>, + typename if_row_major< data_order, tag::contiguous, size_type1 >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.rows(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.cols(); + } + + static value_type* begin_value( Id& id ) { + return id.data(); + } + + static value_type* end_value( Id& id ) { + return id.data() + id.size(); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.cols(); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return id.rows(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/eigen/sparsematrix.hpp b/sdk/boost/numeric/bindings/eigen/sparsematrix.hpp new file mode 100644 index 0000000..95cf5cb --- /dev/null +++ b/sdk/boost/numeric/bindings/eigen/sparsematrix.hpp @@ -0,0 +1,92 @@ +// +// Copyright (c) 2009--2010 +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_EIGEN_SPARSEMATRIX_HPP +#define BOOST_NUMERIC_BINDINGS_EIGEN_SPARSEMATRIX_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< int Value > +struct eigen_data_order { + typedef typename mpl::if_< + mpl::bool_< Value & Eigen::RowMajorBit >, + tag::row_major, + tag::column_major + >::type type; +}; + +template< typename T, int Flags, typename Id, typename Enable > +struct adaptor< Eigen::SparseMatrix< T, Flags >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename copy_const< + Id, + //??? (Sorry, couldn't find it. Maybe fix it later.) + std::ptrdiff_t + >::type index_type; + typedef typename eigen_data_order< Flags >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::index_type, index_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::compressed_sparse >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::index_base, mpl::int_<0> > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.rows(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.cols(); + } + + static value_type* begin_value( Id& id ) { + return id._valuePtr(); + } + + static value_type* end_value( Id& id ) { + return id._valuePtr() + id.nonZeros(); + } + + static index_type* begin_compressed_index_major( Id& id ) { + return id._outerIndexPtr(); + } + + static index_type* end_compressed_index_major( Id& id ) { + return id._outerIndexPtr() + id.outerSize() + 1; + } + + static index_type* begin_index_minor( Id& id ) { + return id._innerIndexPtr(); + } + + static index_type* end_index_minor( Id& id ) { + return id._innerIndexPtr() + id.nonZeros(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/end.hpp b/sdk/boost/numeric/bindings/end.hpp new file mode 100644 index 0000000..cfaa578 --- /dev/null +++ b/sdk/boost/numeric/bindings/end.hpp @@ -0,0 +1,139 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_END_HPP +#define BOOST_NUMERIC_BINDINGS_END_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +namespace detail { + +template< typename T, typename Tag > +struct end_impl {}; + +template< typename T > +struct end_impl< T, tag::value > { + typedef typename bindings::value_type< T>::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::end_value( t ); + } +}; + +template< typename T, int N > +struct end_impl< T, tag::addressing_index > { + + typedef tag::addressing_index tag_type; + + typedef linear_iterator< + typename bindings::value_type< T>::type, + typename result_of::stride< T, tag_type >::type + > result_type; + + static result_type invoke( T& t ) { + return result_type( adaptor_access::end_value( t ), stride(t, tag_type() ) ); + } +}; + +template< typename T > +struct end_impl< T, tag::index_major > { + typedef typename detail::property_at< T, tag::index_type >::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::end_index_major( t ); + } +}; + +template< typename T > +struct end_impl< T, tag::compressed_index_major > { + typedef typename detail::property_at< T, tag::index_type >::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::end_compressed_index_major( t ); + } +}; + +template< typename T > +struct end_impl< T, tag::index_minor > { + typedef typename detail::property_at< T, tag::index_type >::type* result_type; + + static result_type invoke( T& t ) { + return adaptor_access::end_index_minor( t ); + } +}; + +} // namespace detail + +namespace result_of { + +template< typename T, typename Tag = tag::addressing_index<1> > +struct end { + BOOST_STATIC_ASSERT( (is_tag::value) ); + typedef typename detail::end_impl::result_type type; +}; + +} // namespace result_of + +// +// Free Functions +// + +// +// Overloads like end( t, tag ); +// +template< typename T, typename Tag > +inline typename result_of::end::type +end( T& t, Tag ) { + return detail::end_impl::invoke( t ); +} + +template< typename T, typename Tag > +inline typename result_of::end::type +end( const T& t, Tag ) { + return detail::end_impl::invoke( t ); +} + +// Overloads for types with rank <= 1 (scalars, vectors) +// In theory, we could provide overloads for matrices here, too, +// if their minimal_rank is at most 1. + +template< typename T > +typename boost::enable_if< mpl::less< rank, mpl::int_<2> >, + typename result_of::end< T, tag::addressing_index<1> >::type >::type +end( T& t ) { + return detail::end_impl >::invoke( t ); +} + +template< typename T > +typename boost::enable_if< mpl::less< rank, mpl::int_<2> >, + typename result_of::end< const T >::type >::type +end( const T& t ) { + return detail::end_impl >::invoke( t ); +} + +#define GENERATE_END_INDEX( z, which, unused ) \ +GENERATE_FUNCTIONS( end, which, mpl::int_ ) + +BOOST_PP_REPEAT_FROM_TO(1,3,GENERATE_END_INDEX,~) +GENERATE_FUNCTIONS( end, _value, tag::value ) +GENERATE_FUNCTIONS( end, _row, tag::addressing_index<1> ) +GENERATE_FUNCTIONS( end, _column, tag::addressing_index<2> ) + +GENERATE_FUNCTIONS( end, _index_major, tag::index_major ) +GENERATE_FUNCTIONS( end, _compressed_index_major, tag::compressed_index_major ) +GENERATE_FUNCTIONS( end, _index_minor, tag::index_minor ) + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/glas/compressed.hpp b/sdk/boost/numeric/bindings/glas/compressed.hpp new file mode 100644 index 0000000..f3bd246 --- /dev/null +++ b/sdk/boost/numeric/bindings/glas/compressed.hpp @@ -0,0 +1,84 @@ +// +// Copyright (c) 2009--2010 +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_GLAS_COMPRESSED_HPP +#define BOOST_NUMERIC_BINDINGS_GLAS_COMPRESSED_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename O, typename IndexType, typename NNZType, int IB, typename Id, typename Enable > +struct adaptor< glas::sparse_matrix< T, glas::compressed_sparse_structure >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename copy_const< Id, IndexType >::type index_type; + typedef typename convert_to< tag::data_order, O >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::index_type, index_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::compressed_sparse >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::index_base, mpl::int_ > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.num_rows(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.num_columns(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.value_array() ); + } + + static value_type* end_value( Id& id ) { + return bindings::begin_value( id.value_array() ) + id.nnz(); + } + + static index_type* begin_compressed_index_major( Id& id ) { + return bindings::begin_value( id.sparse_structure().compressed_index_array() ); + } + + static index_type* end_compressed_index_major( Id& id ) { + return bindings::end_value( id.sparse_structure().compressed_index_array() ); + } + + static index_type* begin_index_minor( Id& id ) { + return bindings::begin_value( id.sparse_structure().index_array() ); + } + + static index_type* end_index_minor( Id& id ) { + return bindings::begin_value( id.sparse_structure().index_array() ) + id.nnz(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/glas/dense_matrix.hpp b/sdk/boost/numeric/bindings/glas/dense_matrix.hpp new file mode 100644 index 0000000..a63f43f --- /dev/null +++ b/sdk/boost/numeric/bindings/glas/dense_matrix.hpp @@ -0,0 +1,71 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DENSE_MATRIX_HPP +#define BOOST_NUMERIC_BINDINGS_GLAS_DENSE_MATRIX_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename O, typename Id, typename Enable > +struct adaptor< glas::dense_matrix< T, O >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename convert_to< tag::data_order, O >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::stride_type<1>, + typename if_row_major< data_order, std::ptrdiff_t, tag::contiguous >::type >, + mpl::pair< tag::stride_type<2>, + typename if_row_major< data_order, tag::contiguous, std::ptrdiff_t >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.num_rows(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.num_columns(); + } + + static value_type* begin_value( Id& id ) { + return id.storage_ptr(); + } + + static value_type* end_value( Id& id ) { + return id.storage_ptr() + id.num_rows() * id.num_columns(); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.num_columns(); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return id.num_rows(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/glas/dense_vector.hpp b/sdk/boost/numeric/bindings/glas/dense_vector.hpp new file mode 100644 index 0000000..5f42530 --- /dev/null +++ b/sdk/boost/numeric/bindings/glas/dense_vector.hpp @@ -0,0 +1,51 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DENSE_VECTOR_HPP +#define BOOST_NUMERIC_BINDINGS_GLAS_DENSE_VECTOR_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable > +struct adaptor< glas::dense_vector< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return id.storage_ptr(); + } + + static value_type* end_value( Id& id ) { + return id.storage_ptr() + id.size(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/glas/dense_vector_collection.hpp b/sdk/boost/numeric/bindings/glas/dense_vector_collection.hpp new file mode 100644 index 0000000..ee97d17 --- /dev/null +++ b/sdk/boost/numeric/bindings/glas/dense_vector_collection.hpp @@ -0,0 +1,84 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DENSE_VECTOR_COLLECTION_HPP +#define BOOST_NUMERIC_BINDINGS_GLAS_DENSE_VECTOR_COLLECTION_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +// Need a helper type here, because +// glas::fixed_size doesn't work for any T +template< typename T, typename Enable = void > +struct glas_vector_size_type { + typedef std::ptrdiff_t type; +}; + +template< typename T > +struct glas_vector_size_type< + T, typename boost::enable_if< glas::FixedSizeVectorExpression >::type > { + typedef mpl::int_< glas::fixed_size::value > type; +}; + +template< typename T, typename Id > +struct adaptor< T, Id, typename boost::enable_if< glas::DenseVectorCollection >::type > { + + typedef typename copy_const< Id, typename glas::value_type::type >::type value_type; + typedef typename glas_vector_size_type< T >::type size_type1; + typedef typename mpl::if_< + glas::ContiguousDenseVectorCollection, + tag::contiguous, + std::ptrdiff_t + >::type stride_type1; + + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, size_type1 >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, stride_type1 > + > property_map; + + // Only called in case of dynamic sizes + static std::ptrdiff_t size1( const Id& id ) { + return glas::size( id ); + } + + static value_type* begin_value( Id& id ) { + return glas::storage_ptr( id ); + } + + static value_type* end_value( Id& id ) { + return glas::storage_ptr( id ) + offset( id, bindings::size1( id ) ); + } + + // Only called in case of dynamic strides + static std::ptrdiff_t stride1( const Id& id ) { + return glas::stride( id ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/glas/detail/convert_to.hpp b/sdk/boost/numeric/bindings/glas/detail/convert_to.hpp new file mode 100644 index 0000000..53a40fd --- /dev/null +++ b/sdk/boost/numeric/bindings/glas/detail/convert_to.hpp @@ -0,0 +1,36 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_GLAS_DETAIL_CONVERT_TO_HPP +#define BOOST_NUMERIC_BINDINGS_GLAS_DETAIL_CONVERT_TO_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template<> +struct convert_to< bindings::tag::data_order, glas::row_orientation > { + typedef bindings::tag::row_major type; +}; + +template<> +struct convert_to< bindings::tag::data_order, glas::column_orientation > { + typedef bindings::tag::column_major type; +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/has_band_array.hpp b/sdk/boost/numeric/bindings/has_band_array.hpp new file mode 100644 index 0000000..b540be7 --- /dev/null +++ b/sdk/boost/numeric/bindings/has_band_array.hpp @@ -0,0 +1,28 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HAS_BAND_ARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_HAS_BAND_ARRAY_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct has_band_array: + detail::is_same_at< T, tag::data_structure, tag::band_array > {}; + + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/has_linear_array.hpp b/sdk/boost/numeric/bindings/has_linear_array.hpp new file mode 100644 index 0000000..b71d597 --- /dev/null +++ b/sdk/boost/numeric/bindings/has_linear_array.hpp @@ -0,0 +1,32 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HAS_LINEAR_ARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_HAS_LINEAR_ARRAY_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T, typename Enable = void > +struct has_linear_array: mpl::false_ {}; + +template< typename T > +struct has_linear_array< + T, + typename boost::enable_if< detail::is_adaptable >::type >: + detail::is_same_at< T, tag::data_structure, tag::linear_array > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/has_rank.hpp b/sdk/boost/numeric/bindings/has_rank.hpp new file mode 100644 index 0000000..40fe7fc --- /dev/null +++ b/sdk/boost/numeric/bindings/has_rank.hpp @@ -0,0 +1,36 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HAS_RANK_HPP +#define BOOST_NUMERIC_BINDINGS_HAS_RANK_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T, int N, typename Enable = void > +struct has_rank {}; + +template< typename T, int N > +struct has_rank< + T, N, + typename boost::enable_if< detail::is_adaptable >::type + >: + mpl::equal_to< + typename detail::property_at< T, tag::entity >::type, + mpl::int_< N > + > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/has_static_size.hpp b/sdk/boost/numeric/bindings/has_static_size.hpp new file mode 100644 index 0000000..fedac11 --- /dev/null +++ b/sdk/boost/numeric/bindings/has_static_size.hpp @@ -0,0 +1,52 @@ +// +// Copyright (c) 2010 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HAS_STATIC_SIZE_HPP +#define BOOST_NUMERIC_BINDINGS_HAS_STATIC_SIZE_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T > +struct is_static_size_property: mpl::false_ {}; + +template< int N, int M > +struct is_static_size_property< mpl::pair< tag::size_type, mpl::int_ > >: mpl::true_ {}; + +} // namespace detail + +template< typename T, typename Enable = void > +struct has_static_size: mpl::false_ {}; + +template< typename T > +struct has_static_size< + T, + typename boost::enable_if< detail::is_adaptable >::type >: + + // count the number of static size properties, + // should be equal to the rank of the object + mpl::equal_to< + mpl::count_if< + typename detail::property_map_of< T >::type, + detail::is_static_size_property< mpl::_ > + >, + typename detail::property_at< T, tag::entity >::type + >::type {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/has_static_stride.hpp b/sdk/boost/numeric/bindings/has_static_stride.hpp new file mode 100644 index 0000000..f491323 --- /dev/null +++ b/sdk/boost/numeric/bindings/has_static_stride.hpp @@ -0,0 +1,52 @@ +// +// Copyright (c) 2010 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HAS_STATIC_STRIDE_HPP +#define BOOST_NUMERIC_BINDINGS_HAS_STATIC_STRIDE_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T > +struct is_static_stride_property: mpl::false_ {}; + +template< int N, int M > +struct is_static_stride_property< mpl::pair< tag::stride_type, mpl::int_ > >: mpl::true_ {}; + +} // namespace detail + +template< typename T, typename Enable = void > +struct has_static_stride: mpl::false_ {}; + +template< typename T > +struct has_static_stride< + T, + typename boost::enable_if< detail::is_adaptable >::type >: + + // count the number of static stride properties, + // should be equal to the rank of the object + mpl::equal_to< + mpl::count_if< + typename detail::property_map_of< T >::type, + detail::is_static_stride_property< mpl::_ > + >, + typename detail::property_at< T, tag::entity >::type + >::type {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/has_triangular_array.hpp b/sdk/boost/numeric/bindings/has_triangular_array.hpp new file mode 100644 index 0000000..159624c --- /dev/null +++ b/sdk/boost/numeric/bindings/has_triangular_array.hpp @@ -0,0 +1,27 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HAS_TRIANGULAR_ARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_HAS_TRIANGULAR_ARRAY_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct has_triangular_array: + detail::is_same_at< T, tag::data_structure, tag::triangular_array > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/herm.hpp b/sdk/boost/numeric/bindings/herm.hpp new file mode 100644 index 0000000..cd86466 --- /dev/null +++ b/sdk/boost/numeric/bindings/herm.hpp @@ -0,0 +1,44 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_HERM_HPP +#define BOOST_NUMERIC_BINDINGS_HERM_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct herm { + typedef detail::basic_wrapper< + T, + mpl::pair< tag::matrix_type, tag::hermitian > + > type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::herm< T >::type const herm( T& underlying ) { + return typename result_of::herm< T >::type( underlying ); +} + +template< typename T > +typename result_of::herm< const T >::type const herm( const T& underlying ) { + return typename result_of::herm< const T >::type( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/index_base.hpp b/sdk/boost/numeric/bindings/index_base.hpp new file mode 100644 index 0000000..886b66e --- /dev/null +++ b/sdk/boost/numeric/bindings/index_base.hpp @@ -0,0 +1,35 @@ +// +// Copyright (c) 2010 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_INDEX_BASE_HPP +#define BOOST_NUMERIC_BINDINGS_INDEX_BASE_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct index_base { + typedef typename detail::property_at< T, tag::index_base >::type type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::index_base::type index_base( const T& ) { + return typename result_of::index_base::type(); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/io.hpp b/sdk/boost/numeric/bindings/io.hpp new file mode 100644 index 0000000..3121e8f --- /dev/null +++ b/sdk/boost/numeric/bindings/io.hpp @@ -0,0 +1,52 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IO_HPP +#define BOOST_NUMERIC_BINDINGS_IO_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Stream, typename T > +Stream& pretty_print( Stream& os, const T& t ) { + namespace bindings = ::boost::numeric::bindings; + os << "[" << size1(t) << "] "; + typename bindings::result_of::begin< const T >::type i = bindings::begin(t); + if ( i != bindings::end(t) ) { + os << *i; + ++i; + } + for( ; i != bindings::end(t); ++i ) { + os << " " << *i; + } + return os; +} + +} // detail +} // bindings +} // numeric +} // boost + + +template< typename T > +std::ostream& operator<<( std::ostream& os, + const boost::numeric::bindings::detail::adaptable_type& object ) { + return boost::numeric::bindings::detail::pretty_print( os, object.derived() ); +} + + +#endif diff --git a/sdk/boost/numeric/bindings/is_column_major.hpp b/sdk/boost/numeric/bindings/is_column_major.hpp new file mode 100644 index 0000000..dd76099 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_column_major.hpp @@ -0,0 +1,32 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_COLUMN_MAJOR_HPP +#define BOOST_NUMERIC_BINDINGS_IS_COLUMN_MAJOR_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_column_major: + mpl::if_< + detail::property_has_key< T, tag::data_order >, + detail::is_same_at< T, tag::data_order, tag::column_major >, + mpl::true_ + >::type {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/is_complex.hpp b/sdk/boost/numeric/bindings/is_complex.hpp new file mode 100644 index 0000000..ff146f6 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_complex.hpp @@ -0,0 +1,25 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_COMPLEX_HPP +#define BOOST_NUMERIC_BINDINGS_IS_COMPLEX_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_complex: boost::is_complex {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/is_mutable.hpp b/sdk/boost/numeric/bindings/is_mutable.hpp new file mode 100644 index 0000000..3c185e4 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_mutable.hpp @@ -0,0 +1,33 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_MUTABLE_HPP +#define BOOST_NUMERIC_BINDINGS_IS_MUTABLE_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T, typename Enable = void > +struct is_mutable: mpl::false_ {}; + +template< typename T > +struct is_mutable< T, typename boost::enable_if< detail::is_adaptable >::type >: + is_same< + typename bindings::value_type< T>::type, + typename remove_const< typename bindings::value_type< T>::type >::type + > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/is_numeric.hpp b/sdk/boost/numeric/bindings/is_numeric.hpp new file mode 100644 index 0000000..4067d66 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_numeric.hpp @@ -0,0 +1,28 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_NUMERIC_HPP +#define BOOST_NUMERIC_BINDINGS_IS_NUMERIC_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_numeric: mpl::or_< is_real, is_complex, is_integral > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/is_real.hpp b/sdk/boost/numeric/bindings/is_real.hpp new file mode 100644 index 0000000..3aab698 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_real.hpp @@ -0,0 +1,25 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_REAL_HPP +#define BOOST_NUMERIC_BINDINGS_IS_REAL_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_real: boost::is_floating_point {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/is_row_major.hpp b/sdk/boost/numeric/bindings/is_row_major.hpp new file mode 100644 index 0000000..76a5606 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_row_major.hpp @@ -0,0 +1,32 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_ROW_MAJOR_HPP +#define BOOST_NUMERIC_BINDINGS_IS_ROW_MAJOR_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_row_major: + mpl::if_< + detail::property_has_key< T, tag::data_order >, + detail::is_same_at< T, tag::data_order, tag::row_major >, + mpl::false_ + >::type {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/is_symmetric.hpp b/sdk/boost/numeric/bindings/is_symmetric.hpp new file mode 100644 index 0000000..83d3728 --- /dev/null +++ b/sdk/boost/numeric/bindings/is_symmetric.hpp @@ -0,0 +1,27 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_IS_SYMMETRIC_HPP +#define BOOST_NUMERIC_BINDINGS_IS_SYMMETRIC_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_symmetric: + detail::is_same_at< T, tag::matrix_type, tag::symmetric > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack.hpp b/sdk/boost/numeric/bindings/lapack.hpp new file mode 100644 index 0000000..92a3b72 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack.hpp @@ -0,0 +1,16 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_HPP + +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary.hpp new file mode 100644 index 0000000..3260af4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary.hpp @@ -0,0 +1,48 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/ilaenv.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/ilaenv.hpp new file mode 100644 index 0000000..0d1c766 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/ilaenv.hpp @@ -0,0 +1,38 @@ +/* + * + * Copyright (c) Toon Knapen, Kresimir Fresl and Matthias Troyer 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * KF acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ILAENV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_ILAENV_HPP + +#include +#include + +namespace boost { namespace numeric { namespace bindings { namespace lapack { + +// +// ilaenv() is called from the LAPACK routines to choose +// problem-dependent parameters such as the block sizes +// for the local environment. +// + +inline std::ptrdiff_t ilaenv( const fortran_int_t ispec, const char* name, + const char* opts, const fortran_int_t n1 = -1, const fortran_int_t n2 = -1, + const fortran_int_t n3 = -1, const fortran_int_t n4 = -1) { + return LAPACK_ILAENV( &ispec, name, opts, &n1, &n2, &n3, &n4, + std::strlen (name), std::strlen (opts) ); +} + +}}}} + +#endif + diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/labrd.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/labrd.hpp new file mode 100644 index 0000000..54e4c66 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/labrd.hpp @@ -0,0 +1,301 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LABRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LABRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for labrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nb, float* a, const fortran_int_t lda, float* d, + float* e, float* tauq, float* taup, float* x, const fortran_int_t ldx, + float* y, const fortran_int_t ldy ) { + fortran_int_t info(0); + LAPACK_SLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nb, double* a, const fortran_int_t lda, double* d, + double* e, double* tauq, double* taup, double* x, + const fortran_int_t ldx, double* y, const fortran_int_t ldy ) { + fortran_int_t info(0); + LAPACK_DLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nb, std::complex* a, + const fortran_int_t lda, float* d, float* e, + std::complex* tauq, std::complex* taup, + std::complex* x, const fortran_int_t ldx, + std::complex* y, const fortran_int_t ldy ) { + fortran_int_t info(0); + LAPACK_CLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t labrd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nb, std::complex* a, + const fortran_int_t lda, double* d, double* e, + std::complex* tauq, std::complex* taup, + std::complex* x, const fortran_int_t ldx, + std::complex* y, const fortran_int_t ldy ) { + fortran_int_t info(0); + LAPACK_ZLABRD( &m, &n, &nb, a, &lda, d, e, tauq, taup, x, &ldx, y, &ldy ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to labrd. +// +template< typename Value, typename Enable = void > +struct labrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct labrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP, typename MatrixX, + typename MatrixY > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixY >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixY >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(e) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(taup) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(tauq) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::size_minor(y) == 1 || + bindings::stride_minor(y) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::stride_major(y) >= bindings::size_column(a) ); + return detail::labrd( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(tauq), + bindings::begin_value(taup), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(y), + bindings::stride_major(y) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct labrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP, typename MatrixX, + typename MatrixY > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixY >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixY >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(e) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(taup) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(tauq) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::size_minor(y) == 1 || + bindings::stride_minor(y) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(y) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::labrd( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(tauq), + bindings::begin_value(taup), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(y), + bindings::stride_major(y) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the labrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for labrd. Its overload differs for +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP, typename MatrixX, + typename MatrixY > +inline std::ptrdiff_t labrd( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, MatrixX& x, MatrixY& y ) { + return labrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tauq, taup, x, y ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lacgv.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lacgv.hpp new file mode 100644 index 0000000..e23ddd6 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lacgv.hpp @@ -0,0 +1,122 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LACGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LACGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lacgv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lacgv( const fortran_int_t n, std::complex* x, + const fortran_int_t incx ) { + fortran_int_t info(0); + LAPACK_CLACGV( &n, x, &incx ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lacgv( const fortran_int_t n, std::complex* x, + const fortran_int_t incx ) { + fortran_int_t info(0); + LAPACK_ZLACGV( &n, x, &incx ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lacgv. +// +template< typename Value > +struct lacgv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + const fortran_int_t incx ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( n >= 0 ); + return detail::lacgv( n, bindings::begin_value(x), incx ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lacgv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lacgv. Its overload differs for +// +template< typename VectorX > +inline std::ptrdiff_t lacgv( const fortran_int_t n, VectorX& x, + const fortran_int_t incx ) { + return lacgv_impl< typename bindings::value_type< + VectorX >::type >::invoke( n, x, incx ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lacon.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lacon.hpp new file mode 100644 index 0000000..5ff3eaa --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lacon.hpp @@ -0,0 +1,296 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LACON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LACON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lacon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t lacon( const fortran_int_t n, float* v, float* x, + fortran_int_t* isgn, float& est, fortran_int_t& kase ) { + fortran_int_t info(0); + LAPACK_SLACON( &n, v, x, isgn, &est, &kase ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t lacon( const fortran_int_t n, double* v, double* x, + fortran_int_t* isgn, double& est, fortran_int_t& kase ) { + fortran_int_t info(0); + LAPACK_DLACON( &n, v, x, isgn, &est, &kase ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lacon( const fortran_int_t n, std::complex* v, + std::complex* x, float& est, fortran_int_t& kase ) { + fortran_int_t info(0); + LAPACK_CLACON( &n, v, x, &est, &kase ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lacon( const fortran_int_t n, std::complex* v, + std::complex* x, double& est, fortran_int_t& kase ) { + fortran_int_t info(0); + LAPACK_ZLACON( &n, v, x, &est, &kase ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lacon. +// +template< typename Value, typename Enable = void > +struct lacon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct lacon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename V, typename ISGN > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + real_type& est, fortran_int_t& kase, detail::workspace2< V, + ISGN > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_isgn( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_v( n )); + BOOST_ASSERT( n >= 1 ); + return detail::lacon( n, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(x), + bindings::begin_value(work.select(fortran_int_t())), est, + kase ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + real_type& est, fortran_int_t& kase, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_v( min_size_v( n ) ); + bindings::detail::array< + fortran_int_t > tmp_isgn( min_size_isgn( n ) ); + return invoke( n, x, est, kase, workspace( tmp_v, tmp_isgn ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + real_type& est, fortran_int_t& kase, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( n, x, est, kase, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array v. + // + static std::ptrdiff_t min_size_v( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array isgn. + // + static std::ptrdiff_t min_size_isgn( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct lacon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename V > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + real_type& est, fortran_int_t& kase, detail::workspace1< + V > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_v( n )); + BOOST_ASSERT( n >= 1 ); + return detail::lacon( n, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(x), est, kase ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + real_type& est, fortran_int_t& kase, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_v( min_size_v( n ) ); + return invoke( n, x, est, kase, workspace( tmp_v ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + real_type& est, fortran_int_t& kase, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( n, x, est, kase, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array v. + // + static std::ptrdiff_t min_size_v( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lacon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lacon. Its overload differs for +// * User-defined workspace +// +template< typename VectorX, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lacon( const fortran_int_t n, VectorX& x, typename remove_imaginary< + typename bindings::value_type< VectorX >::type >::type& est, + fortran_int_t& kase, Workspace work ) { + return lacon_impl< typename bindings::value_type< + VectorX >::type >::invoke( n, x, est, kase, work ); +} + +// +// Overloaded function for lacon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorX > +inline typename boost::disable_if< detail::is_workspace< VectorX >, + std::ptrdiff_t >::type +lacon( const fortran_int_t n, VectorX& x, typename remove_imaginary< + typename bindings::value_type< VectorX >::type >::type& est, + fortran_int_t& kase ) { + return lacon_impl< typename bindings::value_type< + VectorX >::type >::invoke( n, x, est, kase, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/laebz.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/laebz.hpp new file mode 100644 index 0000000..e1fe74b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/laebz.hpp @@ -0,0 +1,287 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LAEBZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LAEBZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for laebz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t laebz( const fortran_int_t ijob, + const fortran_int_t nitmax, const fortran_int_t n, + const fortran_int_t mmax, const fortran_int_t minp, + const fortran_int_t nbmin, const float abstol, const float reltol, + const float pivmin, const float* d, const float* e, const float* e2, + fortran_int_t* nval, float* ab, float* c, fortran_int_t& mout, + fortran_int_t* nab, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol, &reltol, + &pivmin, d, e, e2, nval, ab, c, &mout, nab, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t laebz( const fortran_int_t ijob, + const fortran_int_t nitmax, const fortran_int_t n, + const fortran_int_t mmax, const fortran_int_t minp, + const fortran_int_t nbmin, const double abstol, const double reltol, + const double pivmin, const double* d, const double* e, + const double* e2, fortran_int_t* nval, double* ab, double* c, + fortran_int_t& mout, fortran_int_t* nab, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DLAEBZ( &ijob, &nitmax, &n, &mmax, &minp, &nbmin, &abstol, &reltol, + &pivmin, d, e, e2, nval, ab, c, &mout, nab, work, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to laebz. +// +template< typename Value > +struct laebz_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorNVAL, typename MatrixAB, typename VectorC, + typename MatrixNAB, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_int_t nitmax, const fortran_int_t n, + const fortran_int_t minp, const fortran_int_t nbmin, + const real_type abstol, const real_type reltol, + const real_type pivmin, const VectorD& d, const VectorE& e, + const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c, + fortran_int_t& mout, MatrixNAB& nab, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorNVAL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixNAB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorNVAL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixNAB >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n ); + BOOST_ASSERT( bindings::size(e2) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::stride_major(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::stride_major(ab) )); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + return detail::laebz( ijob, nitmax, n, bindings::stride_major(ab), + minp, nbmin, abstol, reltol, pivmin, bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(e2), + bindings::begin_value(nval), bindings::begin_value(ab), + bindings::begin_value(c), mout, bindings::begin_value(nab), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorNVAL, typename MatrixAB, typename VectorC, + typename MatrixNAB > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_int_t nitmax, const fortran_int_t n, + const fortran_int_t minp, const fortran_int_t nbmin, + const real_type abstol, const real_type reltol, + const real_type pivmin, const VectorD& d, const VectorE& e, + const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c, + fortran_int_t& mout, MatrixNAB& nab, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::stride_major(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::stride_major(ab) ) ); + return invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin, + d, e, e2, nval, ab, c, mout, nab, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorNVAL, typename MatrixAB, typename VectorC, + typename MatrixNAB > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_int_t nitmax, const fortran_int_t n, + const fortran_int_t minp, const fortran_int_t nbmin, + const real_type abstol, const real_type reltol, + const real_type pivmin, const VectorD& d, const VectorE& e, + const VectorE2& e2, VectorNVAL& nval, MatrixAB& ab, VectorC& c, + fortran_int_t& mout, MatrixNAB& nab, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( ijob, nitmax, n, minp, nbmin, abstol, reltol, pivmin, + d, e, e2, nval, ab, c, mout, nab, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t mmax ) { + return mmax; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t mmax ) { + return mmax; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the laebz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for laebz. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorNVAL, typename MatrixAB, typename VectorC, + typename MatrixNAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +laebz( const fortran_int_t ijob, const fortran_int_t nitmax, + const fortran_int_t n, const fortran_int_t minp, + const fortran_int_t nbmin, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type abstol, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type reltol, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type pivmin, + const VectorD& d, const VectorE& e, const VectorE2& e2, + VectorNVAL& nval, MatrixAB& ab, VectorC& c, fortran_int_t& mout, + MatrixNAB& nab, Workspace work ) { + return laebz_impl< typename bindings::value_type< + VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol, + reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, work ); +} + +// +// Overloaded function for laebz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorNVAL, typename MatrixAB, typename VectorC, + typename MatrixNAB > +inline typename boost::disable_if< detail::is_workspace< MatrixNAB >, + std::ptrdiff_t >::type +laebz( const fortran_int_t ijob, const fortran_int_t nitmax, + const fortran_int_t n, const fortran_int_t minp, + const fortran_int_t nbmin, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type abstol, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type reltol, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type pivmin, + const VectorD& d, const VectorE& e, const VectorE2& e2, + VectorNVAL& nval, MatrixAB& ab, VectorC& c, fortran_int_t& mout, + MatrixNAB& nab ) { + return laebz_impl< typename bindings::value_type< + VectorD >::type >::invoke( ijob, nitmax, n, minp, nbmin, abstol, + reltol, pivmin, d, e, e2, nval, ab, c, mout, nab, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lalsd.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lalsd.hpp new file mode 100644 index 0000000..6f12582 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lalsd.hpp @@ -0,0 +1,425 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LALSD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LALSD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lalsd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t lalsd( const char uplo, const fortran_int_t smlsiz, + const fortran_int_t n, const fortran_int_t nrhs, float* d, float* e, + float* b, const fortran_int_t ldb, const float rcond, + fortran_int_t& rank, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t lalsd( const char uplo, const fortran_int_t smlsiz, + const fortran_int_t n, const fortran_int_t nrhs, double* d, double* e, + double* b, const fortran_int_t ldb, const double rcond, + fortran_int_t& rank, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lalsd( const char uplo, const fortran_int_t smlsiz, + const fortran_int_t n, const fortran_int_t nrhs, float* d, float* e, + std::complex* b, const fortran_int_t ldb, const float rcond, + fortran_int_t& rank, std::complex* work, float* rwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_CLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank, + work, rwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lalsd( const char uplo, const fortran_int_t smlsiz, + const fortran_int_t n, const fortran_int_t nrhs, double* d, double* e, + std::complex* b, const fortran_int_t ldb, const double rcond, + fortran_int_t& rank, std::complex* work, double* rwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_ZLALSD( &uplo, &smlsiz, &n, &nrhs, d, e, b, &ldb, &rcond, &rank, + work, rwork, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lalsd. +// +template< typename Value, typename Enable = void > +struct lalsd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct lalsd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixB, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char uplo, + const fortran_int_t smlsiz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixB& b, const real_type rcond, + fortran_int_t& rank, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0, + static_cast( + std::log(static_cast(n)/static_cast(smlsiz+ + 1)) / + std::log(static_cast(2.)) ) + 1 ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n, nlvl )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n, smlsiz, nlvl, bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(b) >= 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::lalsd( uplo, smlsiz, n, bindings::size_column(b), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(b), bindings::stride_major(b), rcond, + rank, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( const char uplo, + const fortran_int_t smlsiz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixB& b, const real_type rcond, + fortran_int_t& rank, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0, + static_cast( + std::log(static_cast(n)/static_cast(smlsiz+ + 1)) / + std::log(static_cast(2.)) ) + 1 ); + bindings::detail::array< real_type > tmp_work( min_size_work( n, + smlsiz, nlvl, bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n, nlvl ) ); + return invoke( uplo, smlsiz, n, d, e, b, rcond, rank, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( const char uplo, + const fortran_int_t smlsiz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixB& b, const real_type rcond, + fortran_int_t& rank, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, smlsiz, n, d, e, b, rcond, rank, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t smlsiz, const std::ptrdiff_t nlvl, + const std::ptrdiff_t nrhs ) { + std::ptrdiff_t smlsiz_plus_one = smlsiz + 1; + return 9*n + 2*n*smlsiz + 8*n*nlvl + n*nrhs + + smlsiz_plus_one * smlsiz_plus_one; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const std::ptrdiff_t nlvl ) { + return 3*n*nlvl + 11*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct lalsd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixB, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char uplo, + const fortran_int_t smlsiz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixB& b, const real_type rcond, + fortran_int_t& rank, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0, + static_cast( + std::log(static_cast(n)/ + static_cast(smlsiz+1)) / + std::log(static_cast(2.))) + 1 ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n, nlvl )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( n, smlsiz, nlvl, bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( n, bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(b) >= 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::lalsd( uplo, smlsiz, n, bindings::size_column(b), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(b), bindings::stride_major(b), rcond, + rank, bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( const char uplo, + const fortran_int_t smlsiz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixB& b, const real_type rcond, + fortran_int_t& rank, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t nlvl = std::max< std::ptrdiff_t >( 0, + static_cast( + std::log(static_cast(n)/ + static_cast(smlsiz+1)) / + std::log(static_cast(2.))) + 1 ); + bindings::detail::array< value_type > tmp_work( min_size_work( n, + bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n, + smlsiz, nlvl, bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n, nlvl ) ); + return invoke( uplo, smlsiz, n, d, e, b, rcond, rank, + workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( const char uplo, + const fortran_int_t smlsiz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixB& b, const real_type rcond, + fortran_int_t& rank, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, smlsiz, n, d, e, b, rcond, rank, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*nrhs; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n, + const std::ptrdiff_t smlsiz, const std::ptrdiff_t nlvl, + const std::ptrdiff_t nrhs ) { + std::ptrdiff_t smlsiz_plus_one = smlsiz + 1; + return 9*n + 2*n*smlsiz + 8*n*nlvl + 3*smlsiz*nrhs + + smlsiz_plus_one * smlsiz_plus_one; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const std::ptrdiff_t nlvl ) { + return 3*n*nlvl+11*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lalsd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lalsd. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixB, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lalsd( const char uplo, const fortran_int_t smlsiz, + const fortran_int_t n, VectorD& d, VectorE& e, MatrixB& b, + const typename remove_imaginary< typename bindings::value_type< + MatrixB >::type >::type rcond, fortran_int_t& rank, + Workspace work ) { + return lalsd_impl< typename bindings::value_type< + MatrixB >::type >::invoke( uplo, smlsiz, n, d, e, b, rcond, rank, + work ); +} + +// +// Overloaded function for lalsd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixB > +inline typename boost::disable_if< detail::is_workspace< MatrixB >, + std::ptrdiff_t >::type +lalsd( const char uplo, const fortran_int_t smlsiz, + const fortran_int_t n, VectorD& d, VectorE& e, MatrixB& b, + const typename remove_imaginary< typename bindings::value_type< + MatrixB >::type >::type rcond, fortran_int_t& rank ) { + return lalsd_impl< typename bindings::value_type< + MatrixB >::type >::invoke( uplo, smlsiz, n, d, e, b, rcond, rank, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/langb.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/langb.hpp new file mode 100644 index 0000000..f3800bf --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/langb.hpp @@ -0,0 +1,223 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGB_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGB_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for langb is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t langb( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, const float* ab, + const fortran_int_t ldab, float* work ) { + fortran_int_t info(0); + LAPACK_SLANGB( &norm, &n, &kl, &ku, ab, &ldab, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t langb( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, const double* ab, + const fortran_int_t ldab, double* work ) { + fortran_int_t info(0); + LAPACK_DLANGB( &norm, &n, &kl, &ku, ab, &ldab, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t langb( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const std::complex* ab, const fortran_int_t ldab, + float* work ) { + fortran_int_t info(0); + LAPACK_CLANGB( &norm, &n, &kl, &ku, ab, &ldab, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t langb( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const std::complex* ab, const fortran_int_t ldab, + double* work ) { + fortran_int_t info(0); + LAPACK_ZLANGB( &norm, &n, &kl, &ku, ab, &ldab, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to langb. +// +template< typename Value > +struct langb_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+ + 1 ); + return detail::langb( norm, bindings::size_column(ab), + bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ab) ) ); + return invoke( norm, ab, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, ab, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the langb_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for langb. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +langb( const char norm, const MatrixAB& ab, Workspace work ) { + return langb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, work ); +} + +// +// Overloaded function for langb. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB > +inline typename boost::disable_if< detail::is_workspace< MatrixAB >, + std::ptrdiff_t >::type +langb( const char norm, const MatrixAB& ab ) { + return langb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lange.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lange.hpp new file mode 100644 index 0000000..2ecb8e5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lange.hpp @@ -0,0 +1,218 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGE_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANGE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lange is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t lange( const char norm, const fortran_int_t m, + const fortran_int_t n, const float* a, const fortran_int_t lda, + float* work ) { + fortran_int_t info(0); + LAPACK_SLANGE( &norm, &m, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t lange( const char norm, const fortran_int_t m, + const fortran_int_t n, const double* a, const fortran_int_t lda, + double* work ) { + fortran_int_t info(0); + LAPACK_DLANGE( &norm, &m, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lange( const char norm, const fortran_int_t m, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_CLANGE( &norm, &m, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lange( const char norm, const fortran_int_t m, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, double* work ) { + fortran_int_t info(0); + LAPACK_ZLANGE( &norm, &m, &n, a, &lda, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lange. +// +template< typename Value > +struct lange_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< + std::ptrdiff_t >(bindings::size_row(a),1) ); + return detail::lange( norm, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_row(a) ) ); + return invoke( norm, a, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, a, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t m ) { + if ( norm == 'I' ) + return std::max< std::ptrdiff_t >( 1, m ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lange_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lange. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lange( const char norm, const MatrixA& a, Workspace work ) { + return lange_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, work ); +} + +// +// Overloaded function for lange. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +lange( const char norm, const MatrixA& a ) { + return lange_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp new file mode 100644 index 0000000..4ea0ef1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhb.hpp @@ -0,0 +1,203 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHB_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHB_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lanhb is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lanhb( const char norm, const UpLo, + const fortran_int_t n, const fortran_int_t k, + const std::complex* ab, const fortran_int_t ldab, + float* work ) { + fortran_int_t info(0); + LAPACK_CLANHB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lanhb( const char norm, const UpLo, + const fortran_int_t n, const fortran_int_t k, + const std::complex* ab, const fortran_int_t ldab, + double* work ) { + fortran_int_t info(0); + LAPACK_ZLANHB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab, + work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lanhb. +// +template< typename Value > +struct lanhb_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+1 ); + return detail::lanhb( norm, uplo(), bindings::size_column(ab), + bindings::bandwidth_lower(ab), bindings::begin_value(ab), + bindings::stride_major(ab), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ab) ) ); + return invoke( norm, ab, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( norm, ab, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' || norm == '1' || norm == 'O' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lanhb_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lanhb. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lanhb( const char norm, const MatrixAB& ab, Workspace work ) { + return lanhb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, work ); +} + +// +// Overloaded function for lanhb. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB > +inline typename boost::disable_if< detail::is_workspace< MatrixAB >, + std::ptrdiff_t >::type +lanhb( const char norm, const MatrixAB& ab ) { + return lanhb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp new file mode 100644 index 0000000..217cdbc --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhe.hpp @@ -0,0 +1,196 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHE_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lanhe is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lanhe( const char norm, const UpLo, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_CLANHE( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lanhe( const char norm, const UpLo, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, double* work ) { + fortran_int_t info(0); + LAPACK_ZLANHE( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lanhe. +// +template< typename Value > +struct lanhe_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< + std::ptrdiff_t >(bindings::size_column(a),1) ); + return detail::lanhe( norm, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(a) ) ); + return invoke( norm, a, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( norm, a, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' || norm == '1' || norm == 'O' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lanhe_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lanhe. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lanhe( const char norm, const MatrixA& a, Workspace work ) { + return lanhe_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, work ); +} + +// +// Overloaded function for lanhe. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +lanhe( const char norm, const MatrixA& a ) { + return lanhe_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp new file mode 100644 index 0000000..712ed68 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhp.hpp @@ -0,0 +1,188 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHP_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHP_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lanhp is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lanhp( const char norm, const UpLo, + const fortran_int_t n, const std::complex* ap, float* work ) { + fortran_int_t info(0); + LAPACK_CLANHP( &norm, &lapack_option< UpLo >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lanhp( const char norm, const UpLo, + const fortran_int_t n, const std::complex* ap, double* work ) { + fortran_int_t info(0); + LAPACK_ZLANHP( &norm, &lapack_option< UpLo >::value, &n, ap, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lanhp. +// +template< typename Value > +struct lanhp_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::lanhp( norm, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ap) ) ); + return invoke( norm, ap, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( norm, ap, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' || norm == '1' || norm == 'O' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lanhp_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lanhp. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lanhp( const char norm, const MatrixAP& ap, Workspace work ) { + return lanhp_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, ap, work ); +} + +// +// Overloaded function for lanhp. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP > +inline typename boost::disable_if< detail::is_workspace< MatrixAP >, + std::ptrdiff_t >::type +lanhp( const char norm, const MatrixAP& ap ) { + return lanhp_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, ap, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp new file mode 100644 index 0000000..10a776b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lanhs.hpp @@ -0,0 +1,213 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANHS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lanhs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n, + const float* a, const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_SLANHS( &norm, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n, + const double* a, const fortran_int_t lda, double* work ) { + fortran_int_t info(0); + LAPACK_DLANHS( &norm, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_CLANHS( &norm, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t lanhs( const char norm, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + double* work ) { + fortran_int_t info(0); + LAPACK_ZLANHS( &norm, &n, a, &lda, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lanhs. +// +template< typename Value > +struct lanhs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< + std::ptrdiff_t >(bindings::size_column(a),1) ); + return detail::lanhs( norm, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(a) ) ); + return invoke( norm, a, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, a, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lanhs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lanhs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lanhs( const char norm, const MatrixA& a, Workspace work ) { + return lanhs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, work ); +} + +// +// Overloaded function for lanhs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +lanhs( const char norm, const MatrixA& a ) { + return lanhs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lansb.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lansb.hpp new file mode 100644 index 0000000..7ee287b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lansb.hpp @@ -0,0 +1,233 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSB_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSB_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lansb is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansb( const char norm, const UpLo, + const fortran_int_t n, const fortran_int_t k, const float* ab, + const fortran_int_t ldab, float* work ) { + fortran_int_t info(0); + LAPACK_SLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansb( const char norm, const UpLo, + const fortran_int_t n, const fortran_int_t k, const double* ab, + const fortran_int_t ldab, double* work ) { + fortran_int_t info(0); + LAPACK_DLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansb( const char norm, const UpLo, + const fortran_int_t n, const fortran_int_t k, + const std::complex* ab, const fortran_int_t ldab, + float* work ) { + fortran_int_t info(0); + LAPACK_CLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansb( const char norm, const UpLo, + const fortran_int_t n, const fortran_int_t k, + const std::complex* ab, const fortran_int_t ldab, + double* work ) { + fortran_int_t info(0); + LAPACK_ZLANSB( &norm, &lapack_option< UpLo >::value, &n, &k, ab, &ldab, + work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lansb. +// +template< typename Value > +struct lansb_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+1 ); + return detail::lansb( norm, uplo(), bindings::size_column(ab), + bindings::bandwidth_lower(ab), bindings::begin_value(ab), + bindings::stride_major(ab), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ab) ) ); + return invoke( norm, ab, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( norm, ab, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' || norm == '1' || norm == 'O' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lansb_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lansb. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lansb( const char norm, const MatrixAB& ab, Workspace work ) { + return lansb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, work ); +} + +// +// Overloaded function for lansb. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB > +inline typename boost::disable_if< detail::is_workspace< MatrixAB >, + std::ptrdiff_t >::type +lansb( const char norm, const MatrixAB& ab ) { + return lansb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lansp.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lansp.hpp new file mode 100644 index 0000000..72c2e60 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lansp.hpp @@ -0,0 +1,214 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSP_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSP_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lansp is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansp( const char norm, const UpLo, + const fortran_int_t n, const float* ap, float* work ) { + fortran_int_t info(0); + LAPACK_SLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansp( const char norm, const UpLo, + const fortran_int_t n, const double* ap, double* work ) { + fortran_int_t info(0); + LAPACK_DLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansp( const char norm, const UpLo, + const fortran_int_t n, const std::complex* ap, float* work ) { + fortran_int_t info(0); + LAPACK_CLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansp( const char norm, const UpLo, + const fortran_int_t n, const std::complex* ap, double* work ) { + fortran_int_t info(0); + LAPACK_ZLANSP( &norm, &lapack_option< UpLo >::value, &n, ap, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lansp. +// +template< typename Value > +struct lansp_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::lansp( norm, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ap) ) ); + return invoke( norm, ap, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( norm, ap, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' || norm == '1' || norm == 'O' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lansp_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lansp. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lansp( const char norm, const MatrixAP& ap, Workspace work ) { + return lansp_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, ap, work ); +} + +// +// Overloaded function for lansp. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP > +inline typename boost::disable_if< detail::is_workspace< MatrixAP >, + std::ptrdiff_t >::type +lansp( const char norm, const MatrixAP& ap ) { + return lansp_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, ap, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lansy.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lansy.hpp new file mode 100644 index 0000000..6ee9216 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lansy.hpp @@ -0,0 +1,224 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSY_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANSY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lansy is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansy( const char norm, const UpLo, + const fortran_int_t n, const float* a, const fortran_int_t lda, + float* work ) { + fortran_int_t info(0); + LAPACK_SLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansy( const char norm, const UpLo, + const fortran_int_t n, const double* a, const fortran_int_t lda, + double* work ) { + fortran_int_t info(0); + LAPACK_DLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansy( const char norm, const UpLo, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_CLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t lansy( const char norm, const UpLo, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, double* work ) { + fortran_int_t info(0); + LAPACK_ZLANSY( &norm, &lapack_option< UpLo >::value, &n, a, &lda, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lansy. +// +template< typename Value > +struct lansy_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< + std::ptrdiff_t >(bindings::size_column(a),1) ); + return detail::lansy( norm, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(a) ) ); + return invoke( norm, a, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( norm, a, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' || norm == '1' || norm == 'O' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lansy_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lansy. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lansy( const char norm, const MatrixA& a, Workspace work ) { + return lansy_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, work ); +} + +// +// Overloaded function for lansy. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +lansy( const char norm, const MatrixA& a ) { + return lansy_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lantb.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lantb.hpp new file mode 100644 index 0000000..e4c660c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lantb.hpp @@ -0,0 +1,238 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTB_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTB_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lantb is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantb( const char norm, const char uplo, const Diag, + const fortran_int_t n, const fortran_int_t k, const float* ab, + const fortran_int_t ldab, float* work ) { + fortran_int_t info(0); + LAPACK_SLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab, + &ldab, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantb( const char norm, const char uplo, const Diag, + const fortran_int_t n, const fortran_int_t k, const double* ab, + const fortran_int_t ldab, double* work ) { + fortran_int_t info(0); + LAPACK_DLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab, + &ldab, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantb( const char norm, const char uplo, const Diag, + const fortran_int_t n, const fortran_int_t k, + const std::complex* ab, const fortran_int_t ldab, + float* work ) { + fortran_int_t info(0); + LAPACK_CLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab, + &ldab, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantb( const char norm, const char uplo, const Diag, + const fortran_int_t n, const fortran_int_t k, + const std::complex* ab, const fortran_int_t ldab, + double* work ) { + fortran_int_t info(0); + LAPACK_ZLANTB( &norm, &uplo, &lapack_option< Diag >::value, &n, &k, ab, + &ldab, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lantb. +// +template< typename Value > +struct lantb_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK > + static std::ptrdiff_t invoke( const char norm, const char uplo, + const fortran_int_t k, const MatrixAB& ab, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= k+1 ); + BOOST_ASSERT( k >= 0 ); + return detail::lantb( norm, uplo, diag(), bindings::size_column(ab), + k, bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const char uplo, + const fortran_int_t k, const MatrixAB& ab, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ab) ) ); + return invoke( norm, uplo, k, ab, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const char uplo, + const fortran_int_t k, const MatrixAB& ab, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + return invoke( norm, uplo, k, ab, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lantb_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lantb. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lantb( const char norm, const char uplo, const fortran_int_t k, + const MatrixAB& ab, Workspace work ) { + return lantb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, uplo, k, ab, work ); +} + +// +// Overloaded function for lantb. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB > +inline typename boost::disable_if< detail::is_workspace< MatrixAB >, + std::ptrdiff_t >::type +lantb( const char norm, const char uplo, const fortran_int_t k, + const MatrixAB& ab ) { + return lantb_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, uplo, k, ab, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lantp.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lantp.hpp new file mode 100644 index 0000000..0a50314 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lantp.hpp @@ -0,0 +1,216 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTP_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTP_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lantp is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantp( const char norm, const char uplo, const Diag, + const fortran_int_t n, const float* ap, float* work ) { + fortran_int_t info(0); + LAPACK_SLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantp( const char norm, const char uplo, const Diag, + const fortran_int_t n, const double* ap, double* work ) { + fortran_int_t info(0); + LAPACK_DLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantp( const char norm, const char uplo, const Diag, + const fortran_int_t n, const std::complex* ap, float* work ) { + fortran_int_t info(0); + LAPACK_CLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Diag > +inline std::ptrdiff_t lantp( const char norm, const char uplo, const Diag, + const fortran_int_t n, const std::complex* ap, double* work ) { + fortran_int_t info(0); + LAPACK_ZLANTP( &norm, &uplo, &lapack_option< Diag >::value, &n, ap, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lantp. +// +template< typename Value > +struct lantp_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK > + static std::ptrdiff_t invoke( const char norm, const char uplo, + const MatrixAP& ap, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::lantp( norm, uplo, diag(), bindings::size_column(ap), + bindings::begin_value(ap), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const char uplo, + const MatrixAP& ap, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_column(ap) ) ); + return invoke( norm, uplo, ap, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const char uplo, + const MatrixAP& ap, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + return invoke( norm, uplo, ap, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t n ) { + if ( norm == 'I' ) + return std::max< std::ptrdiff_t >( 1, n ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lantp_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lantp. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lantp( const char norm, const char uplo, const MatrixAP& ap, + Workspace work ) { + return lantp_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, uplo, ap, work ); +} + +// +// Overloaded function for lantp. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP > +inline typename boost::disable_if< detail::is_workspace< MatrixAP >, + std::ptrdiff_t >::type +lantp( const char norm, const char uplo, const MatrixAP& ap ) { + return lantp_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, uplo, ap, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/lantr.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/lantr.hpp new file mode 100644 index 0000000..8e82ce4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/lantr.hpp @@ -0,0 +1,235 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LANTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for lantr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t lantr( const char norm, const UpLo, const Diag, + const fortran_int_t m, const fortran_int_t n, const float* a, + const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_SLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &m, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t lantr( const char norm, const UpLo, const Diag, + const fortran_int_t m, const fortran_int_t n, const double* a, + const fortran_int_t lda, double* work ) { + fortran_int_t info(0); + LAPACK_DLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &m, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t lantr( const char norm, const UpLo, const Diag, + const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, float* work ) { + fortran_int_t info(0); + LAPACK_CLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &m, &n, a, &lda, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t lantr( const char norm, const UpLo, const Diag, + const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + double* work ) { + fortran_int_t info(0); + LAPACK_ZLANTR( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &m, &n, a, &lda, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to lantr. +// +template< typename Value > +struct lantr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( norm, bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< + std::ptrdiff_t >(bindings::size_row(a),1) ); + return detail::lantr( norm, uplo(), diag(), bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( norm, + bindings::size_row(a) ) ); + return invoke( norm, a, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + return invoke( norm, a, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char norm, + const std::ptrdiff_t m ) { + if ( norm == 'I' ) + return std::max< std::ptrdiff_t >( 1, m ); + else + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the lantr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for lantr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +lantr( const char norm, const MatrixA& a, Workspace work ) { + return lantr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, work ); +} + +// +// Overloaded function for lantr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +lantr( const char norm, const MatrixA& a ) { + return lantr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larf.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larf.hpp new file mode 100644 index 0000000..c87efad --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larf.hpp @@ -0,0 +1,362 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t larf( const Side, const fortran_int_t m, + const fortran_int_t n, const float* v, const fortran_int_t incv, + const float tau, float* c, const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SLARF( &lapack_option< Side >::value, &m, &n, v, &incv, &tau, c, + &ldc, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t larf( const Side, const fortran_int_t m, + const fortran_int_t n, const double* v, const fortran_int_t incv, + const double tau, double* c, const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DLARF( &lapack_option< Side >::value, &m, &n, v, &incv, &tau, c, + &ldc, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t larf( const Side, const fortran_int_t m, + const fortran_int_t n, const std::complex* v, + const fortran_int_t incv, const std::complex tau, + std::complex* c, const fortran_int_t ldc, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CLARF( &lapack_option< Side >::value, &m, &n, v, &incv, &tau, c, + &ldc, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t larf( const Side, const fortran_int_t m, + const fortran_int_t n, const std::complex* v, + const fortran_int_t incv, const std::complex tau, + std::complex* c, const fortran_int_t ldc, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZLARF( &lapack_option< Side >::value, &m, &n, v, &incv, &tau, c, + &ldc, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larf. +// +template< typename Value, typename Enable = void > +struct larf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct larf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorV, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const real_type tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::larf( side, bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(v), + bindings::stride(v), tau, bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const real_type tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, v, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const real_type tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, v, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct larf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorV, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const value_type tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::larf( side, bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(v), + bindings::stride(v), tau, bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const value_type tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, v, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const value_type tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, v, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larf. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorV, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larf( const Side side, const VectorV& v, + const typename remove_imaginary< typename bindings::value_type< + VectorV >::type >::type tau, MatrixC& c, Workspace work ) { + return larf_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, work ); +} + +// +// Overloaded function for larf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorV, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larf( const Side side, const VectorV& v, + const typename remove_imaginary< typename bindings::value_type< + VectorV >::type >::type tau, MatrixC& c ) { + return larf_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, optimal_workspace() ); +} + +// +// Overloaded function for larf. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorV, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larf( const Side side, const VectorV& v, + const typename bindings::value_type< VectorV >::type tau, MatrixC& c, + Workspace work ) { + return larf_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, work ); +} + +// +// Overloaded function for larf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorV, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larf( const Side side, const VectorV& v, + const typename bindings::value_type< VectorV >::type tau, + MatrixC& c ) { + return larf_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larfb.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larfb.hpp new file mode 100644 index 0000000..e36cc9d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larfb.hpp @@ -0,0 +1,393 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFB_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFB_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larfb is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t larfb( const Side, const Trans, const char direct, + const char storev, const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, const float* v, const fortran_int_t ldv, + const float* t, const fortran_int_t ldt, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t ldwork ) { + fortran_int_t info(0); + LAPACK_SLARFB( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &direct, &storev, &m, &n, &k, v, &ldv, t, &ldt, c, + &ldc, work, &ldwork ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t larfb( const Side, const Trans, const char direct, + const char storev, const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, const double* v, const fortran_int_t ldv, + const double* t, const fortran_int_t ldt, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t ldwork ) { + fortran_int_t info(0); + LAPACK_DLARFB( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &direct, &storev, &m, &n, &k, v, &ldv, t, &ldt, c, + &ldc, work, &ldwork ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t larfb( const Side, const Trans, const char direct, + const char storev, const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, const std::complex* v, + const fortran_int_t ldv, const std::complex* t, + const fortran_int_t ldt, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t ldwork ) { + fortran_int_t info(0); + LAPACK_CLARFB( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &direct, &storev, &m, &n, &k, v, &ldv, t, &ldt, c, + &ldc, work, &ldwork ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t larfb( const Side, const Trans, const char direct, + const char storev, const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, const std::complex* v, + const fortran_int_t ldv, const std::complex* t, + const fortran_int_t ldt, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t ldwork ) { + fortran_int_t info(0); + LAPACK_ZLARFB( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &direct, &storev, &m, &n, &k, v, &ldv, t, &ldt, c, + &ldc, work, &ldwork ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larfb. +// +template< typename Value, typename Enable = void > +struct larfb_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct larfb_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixV, typename MatrixT, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const char direct, + const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixT >::type order; + typedef typename result_of::trans_tag< MatrixV, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( ldwork, bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + BOOST_ASSERT( bindings::stride_major(t) >= bindings::size_column(t) ); + BOOST_ASSERT( direct == 'F' || direct == 'B' ); + BOOST_ASSERT( storev == 'C' || storev == 'R' ); + return detail::larfb( side, trans(), direct, storev, + bindings::size_row(c), bindings::size_column(c), + bindings::size_column(t), bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), ldwork ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixV, typename MatrixT, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char direct, + const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixT >::type order; + typedef typename result_of::trans_tag< MatrixV, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( ldwork, + bindings::size_column(t) ) ); + return invoke( side, direct, storev, v, t, c, ldwork, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixV, typename MatrixT, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char direct, + const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixT >::type order; + typedef typename result_of::trans_tag< MatrixV, order >::type trans; + return invoke( side, direct, storev, v, t, c, ldwork, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ldwork, + const std::ptrdiff_t k ) { + return ldwork * k; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct larfb_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixV, typename MatrixT, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const char direct, + const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixT >::type order; + typedef typename result_of::trans_tag< MatrixV, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( ldwork, bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + BOOST_ASSERT( bindings::stride_major(t) >= bindings::size_column(t) ); + BOOST_ASSERT( direct == 'F' || direct == 'B' ); + BOOST_ASSERT( storev == 'C' || storev == 'R' ); + return detail::larfb( side, trans(), direct, storev, + bindings::size_row(c), bindings::size_column(c), + bindings::size_column(t), bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), ldwork ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixV, typename MatrixT, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char direct, + const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixT >::type order; + typedef typename result_of::trans_tag< MatrixV, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( ldwork, + bindings::size_column(t) ) ); + return invoke( side, direct, storev, v, t, c, ldwork, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixV, typename MatrixT, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char direct, + const char storev, const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixT >::type order; + typedef typename result_of::trans_tag< MatrixV, order >::type trans; + return invoke( side, direct, storev, v, t, c, ldwork, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ldwork, + const std::ptrdiff_t k ) { + return ldwork * k; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larfb_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larfb. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixV, typename MatrixT, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larfb( const Side side, const char direct, const char storev, + const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork, Workspace work ) { + return larfb_impl< typename bindings::value_type< + MatrixV >::type >::invoke( side, direct, storev, v, t, c, ldwork, + work ); +} + +// +// Overloaded function for larfb. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixV, typename MatrixT, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larfb( const Side side, const char direct, const char storev, + const MatrixV& v, const MatrixT& t, MatrixC& c, + const fortran_int_t ldwork ) { + return larfb_impl< typename bindings::value_type< + MatrixV >::type >::invoke( side, direct, storev, v, t, c, ldwork, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larfg.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larfg.hpp new file mode 100644 index 0000000..10fc213 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larfg.hpp @@ -0,0 +1,195 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFG_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFG_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larfg is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t larfg( const fortran_int_t n, float& alpha, float* x, + const fortran_int_t incx, float& tau ) { + fortran_int_t info(0); + LAPACK_SLARFG( &n, &alpha, x, &incx, &tau ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t larfg( const fortran_int_t n, double& alpha, double* x, + const fortran_int_t incx, double& tau ) { + fortran_int_t info(0); + LAPACK_DLARFG( &n, &alpha, x, &incx, &tau ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t larfg( const fortran_int_t n, std::complex& alpha, + std::complex* x, const fortran_int_t incx, + std::complex& tau ) { + fortran_int_t info(0); + LAPACK_CLARFG( &n, &alpha, x, &incx, &tau ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t larfg( const fortran_int_t n, + std::complex& alpha, std::complex* x, + const fortran_int_t incx, std::complex& tau ) { + fortran_int_t info(0); + LAPACK_ZLARFG( &n, &alpha, x, &incx, &tau ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larfg. +// +template< typename Value, typename Enable = void > +struct larfg_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct larfg_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, real_type& alpha, + VectorX& x, real_type& tau ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + return detail::larfg( n, alpha, bindings::begin_value(x), + bindings::stride(x), tau ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct larfg_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t n, value_type& alpha, + VectorX& x, value_type& tau ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + return detail::larfg( n, alpha, bindings::begin_value(x), + bindings::stride(x), tau ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larfg_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larfg. Its overload differs for +// +template< typename VectorX > +inline std::ptrdiff_t larfg( const fortran_int_t n, + typename remove_imaginary< typename bindings::value_type< + VectorX >::type >::type& alpha, VectorX& x, typename remove_imaginary< + typename bindings::value_type< VectorX >::type >::type& tau ) { + return larfg_impl< typename bindings::value_type< + VectorX >::type >::invoke( n, alpha, x, tau ); +} + +// +// Overloaded function for larfg. Its overload differs for +// +template< typename VectorX > +inline std::ptrdiff_t larfg( const fortran_int_t n, + typename bindings::value_type< VectorX >::type& alpha, VectorX& x, + typename bindings::value_type< VectorX >::type& tau ) { + return larfg_impl< typename bindings::value_type< + VectorX >::type >::invoke( n, alpha, x, tau ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larft.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larft.hpp new file mode 100644 index 0000000..644e3e6 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larft.hpp @@ -0,0 +1,179 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFT_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFT_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larft is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t larft( const char direct, const char storev, + const fortran_int_t n, const fortran_int_t k, float* v, + const fortran_int_t ldv, const float* tau, float* t, + const fortran_int_t ldt ) { + fortran_int_t info(0); + LAPACK_SLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t larft( const char direct, const char storev, + const fortran_int_t n, const fortran_int_t k, double* v, + const fortran_int_t ldv, const double* tau, double* t, + const fortran_int_t ldt ) { + fortran_int_t info(0); + LAPACK_DLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t larft( const char direct, const char storev, + const fortran_int_t n, const fortran_int_t k, std::complex* v, + const fortran_int_t ldv, const std::complex* tau, + std::complex* t, const fortran_int_t ldt ) { + fortran_int_t info(0); + LAPACK_CLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t larft( const char direct, const char storev, + const fortran_int_t n, const fortran_int_t k, std::complex* v, + const fortran_int_t ldv, const std::complex* tau, + std::complex* t, const fortran_int_t ldt ) { + fortran_int_t info(0); + LAPACK_ZLARFT( &direct, &storev, &n, &k, v, &ldv, tau, t, &ldt ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larft. +// +template< typename Value > +struct larft_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixV, typename VectorTAU, typename MatrixT > + static std::ptrdiff_t invoke( const char direct, const char storev, + const fortran_int_t n, const fortran_int_t k, MatrixV& v, + const VectorTAU& tau, MatrixT& t ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixV >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_ASSERT( bindings::size(tau) >= k ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::stride_major(t) >= k ); + BOOST_ASSERT( direct == 'F' || direct == 'B' ); + BOOST_ASSERT( k >= 1 ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( storev == 'C' || storev == 'R' ); + return detail::larft( direct, storev, n, k, bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(tau), + bindings::begin_value(t), bindings::stride_major(t) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larft_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larft. Its overload differs for +// +template< typename MatrixV, typename VectorTAU, typename MatrixT > +inline std::ptrdiff_t larft( const char direct, const char storev, + const fortran_int_t n, const fortran_int_t k, MatrixV& v, + const VectorTAU& tau, MatrixT& t ) { + return larft_impl< typename bindings::value_type< + MatrixV >::type >::invoke( direct, storev, n, k, v, tau, t ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larfx.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larfx.hpp new file mode 100644 index 0000000..06ac150 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larfx.hpp @@ -0,0 +1,364 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARFX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larfx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t larfx( const Side, const fortran_int_t m, + const fortran_int_t n, const float* v, const float tau, float* c, + const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SLARFX( &lapack_option< Side >::value, &m, &n, v, &tau, c, &ldc, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t larfx( const Side, const fortran_int_t m, + const fortran_int_t n, const double* v, const double tau, double* c, + const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DLARFX( &lapack_option< Side >::value, &m, &n, v, &tau, c, &ldc, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t larfx( const Side, const fortran_int_t m, + const fortran_int_t n, const std::complex* v, + const std::complex tau, std::complex* c, + const fortran_int_t ldc, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CLARFX( &lapack_option< Side >::value, &m, &n, v, &tau, c, &ldc, + work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t larfx( const Side, const fortran_int_t m, + const fortran_int_t n, const std::complex* v, + const std::complex tau, std::complex* c, + const fortran_int_t ldc, std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZLARFX( &lapack_option< Side >::value, &m, &n, v, &tau, c, &ldc, + work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larfx. +// +template< typename Value, typename Enable = void > +struct larfx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct larfx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorV, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const real_type tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::larfx( side, bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(v), tau, + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const real_type tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, v, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const real_type tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, v, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + std::ptrdiff_t order = bindings::detail::if_left( side, n, m ); + if ( order < 11) + return 1; + else + return std::max< std::ptrdiff_t >( 1, order ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct larfx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorV, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const value_type tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::larfx( side, bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(v), tau, + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const value_type tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, v, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const VectorV& v, + const value_type tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, v, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + std::ptrdiff_t order = bindings::detail::if_left( side, n, m ); + if ( order < 11) + return 1; + else + return std::max< std::ptrdiff_t >( 1, order ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larfx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larfx. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorV, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larfx( const Side side, const VectorV& v, + const typename remove_imaginary< typename bindings::value_type< + VectorV >::type >::type tau, MatrixC& c, Workspace work ) { + return larfx_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, work ); +} + +// +// Overloaded function for larfx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorV, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larfx( const Side side, const VectorV& v, + const typename remove_imaginary< typename bindings::value_type< + VectorV >::type >::type tau, MatrixC& c ) { + return larfx_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, optimal_workspace() ); +} + +// +// Overloaded function for larfx. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorV, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larfx( const Side side, const VectorV& v, + const typename bindings::value_type< VectorV >::type tau, MatrixC& c, + Workspace work ) { + return larfx_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, work ); +} + +// +// Overloaded function for larfx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorV, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larfx( const Side side, const VectorV& v, + const typename bindings::value_type< VectorV >::type tau, + MatrixC& c ) { + return larfx_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, v, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/largv.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/largv.hpp new file mode 100644 index 0000000..b9e6d3a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/largv.hpp @@ -0,0 +1,210 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for largv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t largv( const fortran_int_t n, float* x, + const fortran_int_t incx, float* y, const fortran_int_t incy, + float* c, const fortran_int_t incc ) { + fortran_int_t info(0); + LAPACK_SLARGV( &n, x, &incx, y, &incy, c, &incc ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t largv( const fortran_int_t n, double* x, + const fortran_int_t incx, double* y, const fortran_int_t incy, + double* c, const fortran_int_t incc ) { + fortran_int_t info(0); + LAPACK_DLARGV( &n, x, &incx, y, &incy, c, &incc ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t largv( const fortran_int_t n, std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy, float* c, const fortran_int_t incc ) { + fortran_int_t info(0); + LAPACK_CLARGV( &n, x, &incx, y, &incy, c, &incc ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t largv( const fortran_int_t n, std::complex* x, + const fortran_int_t incx, std::complex* y, + const fortran_int_t incy, double* c, const fortran_int_t incc ) { + fortran_int_t info(0); + LAPACK_ZLARGV( &n, x, &incx, y, &incy, c, &incc ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to largv. +// +template< typename Value, typename Enable = void > +struct largv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct largv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename VectorC > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + VectorY& y, VectorC& c ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_ASSERT( bindings::size(c) >= 1+(n-1)*bindings::stride(c) ); + BOOST_ASSERT( bindings::size(x) >= 1+(n-1)*bindings::stride(x) ); + BOOST_ASSERT( bindings::size(y) >= 1+(n-1)*bindings::stride(y) ); + return detail::largv( n, bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), bindings::begin_value(c), + bindings::stride(c) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct largv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorX, typename VectorY, typename VectorC > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorX& x, + VectorY& y, VectorC& c ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorX >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_ASSERT( bindings::size(c) >= 1+(n-1)*bindings::stride(c) ); + BOOST_ASSERT( bindings::size(x) >= 1+(n-1)*bindings::stride(x) ); + BOOST_ASSERT( bindings::size(y) >= 1+(n-1)*bindings::stride(y) ); + return detail::largv( n, bindings::begin_value(x), + bindings::stride(x), bindings::begin_value(y), + bindings::stride(y), bindings::begin_value(c), + bindings::stride(c) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the largv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for largv. Its overload differs for +// +template< typename VectorX, typename VectorY, typename VectorC > +inline std::ptrdiff_t largv( const fortran_int_t n, VectorX& x, + VectorY& y, VectorC& c ) { + return largv_impl< typename bindings::value_type< + VectorX >::type >::invoke( n, x, y, c ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larnv.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larnv.hpp new file mode 100644 index 0000000..089dd1a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larnv.hpp @@ -0,0 +1,149 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARNV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARNV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larnv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed, + const fortran_int_t n, float* x ) { + fortran_int_t info(0); + LAPACK_SLARNV( &idist, iseed, &n, x ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed, + const fortran_int_t n, double* x ) { + fortran_int_t info(0); + LAPACK_DLARNV( &idist, iseed, &n, x ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed, + const fortran_int_t n, std::complex* x ) { + fortran_int_t info(0); + LAPACK_CLARNV( &idist, iseed, &n, x ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t larnv( const fortran_int_t idist, fortran_int_t* iseed, + const fortran_int_t n, std::complex* x ) { + fortran_int_t info(0); + LAPACK_ZLARNV( &idist, iseed, &n, x ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larnv. +// +template< typename Value > +struct larnv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorISEED, typename VectorX > + static std::ptrdiff_t invoke( const fortran_int_t idist, + VectorISEED& iseed, const fortran_int_t n, VectorX& x ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISEED >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size(iseed) >= 4 ); + BOOST_ASSERT( bindings::size(x) >= n ); + return detail::larnv( idist, bindings::begin_value(iseed), n, + bindings::begin_value(x) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larnv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larnv. Its overload differs for +// +template< typename VectorISEED, typename VectorX > +inline std::ptrdiff_t larnv( const fortran_int_t idist, + VectorISEED& iseed, const fortran_int_t n, VectorX& x ) { + return larnv_impl< typename bindings::value_type< + VectorX >::type >::invoke( idist, iseed, n, x ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larrb.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larrb.hpp new file mode 100644 index 0000000..e110ef7 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larrb.hpp @@ -0,0 +1,271 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRB_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRB_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larrb is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t larrb( const fortran_int_t n, const float* d, + const float* lld, const fortran_int_t ifirst, + const fortran_int_t ilast, const float rtol1, const float rtol2, + const fortran_int_t offset, float* w, float* wgap, float* werr, + float* work, fortran_int_t* iwork, const float pivmin, + const float spdiam, const fortran_int_t twist ) { + fortran_int_t info(0); + LAPACK_SLARRB( &n, d, lld, &ifirst, &ilast, &rtol1, &rtol2, &offset, w, + wgap, werr, work, iwork, &pivmin, &spdiam, &twist, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t larrb( const fortran_int_t n, const double* d, + const double* lld, const fortran_int_t ifirst, + const fortran_int_t ilast, const double rtol1, const double rtol2, + const fortran_int_t offset, double* w, double* wgap, double* werr, + double* work, fortran_int_t* iwork, const double pivmin, + const double spdiam, const fortran_int_t twist ) { + fortran_int_t info(0); + LAPACK_DLARRB( &n, d, lld, &ifirst, &ilast, &rtol1, &rtol2, &offset, w, + wgap, werr, work, iwork, &pivmin, &spdiam, &twist, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larrb. +// +template< typename Value > +struct larrb_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorLLD, typename VectorW, + typename VectorWGAP, typename VectorWERR, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorLLD& lld, const fortran_int_t ifirst, + const fortran_int_t ilast, const real_type rtol1, + const real_type rtol2, const fortran_int_t offset, VectorW& w, + VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin, + const real_type spdiam, const fortran_int_t twist, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorLLD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWGAP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWGAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWERR >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(lld) >= n-1 ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(werr) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + return detail::larrb( n, bindings::begin_value(d), + bindings::begin_value(lld), ifirst, ilast, rtol1, rtol2, + offset, bindings::begin_value(w), bindings::begin_value(wgap), + bindings::begin_value(werr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + pivmin, spdiam, twist ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorLLD, typename VectorW, + typename VectorWGAP, typename VectorWERR > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorLLD& lld, const fortran_int_t ifirst, + const fortran_int_t ilast, const real_type rtol1, + const real_type rtol2, const fortran_int_t offset, VectorW& w, + VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin, + const real_type spdiam, const fortran_int_t twist, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, + wgap, werr, pivmin, spdiam, twist, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorLLD, typename VectorW, + typename VectorWGAP, typename VectorWERR > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorLLD& lld, const fortran_int_t ifirst, + const fortran_int_t ilast, const real_type rtol1, + const real_type rtol2, const fortran_int_t offset, VectorW& w, + VectorWGAP& wgap, VectorWERR& werr, const real_type pivmin, + const real_type spdiam, const fortran_int_t twist, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, + wgap, werr, pivmin, spdiam, twist, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larrb_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larrb. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorLLD, typename VectorW, + typename VectorWGAP, typename VectorWERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larrb( const fortran_int_t n, const VectorD& d, const VectorLLD& lld, + const fortran_int_t ifirst, const fortran_int_t ilast, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type rtol1, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type rtol2, + const fortran_int_t offset, VectorW& w, VectorWGAP& wgap, + VectorWERR& werr, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type pivmin, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type spdiam, const fortran_int_t twist, + Workspace work ) { + return larrb_impl< typename bindings::value_type< + VectorD >::type >::invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, + offset, w, wgap, werr, pivmin, spdiam, twist, work ); +} + +// +// Overloaded function for larrb. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorLLD, typename VectorW, + typename VectorWGAP, typename VectorWERR > +inline typename boost::disable_if< detail::is_workspace< VectorWERR >, + std::ptrdiff_t >::type +larrb( const fortran_int_t n, const VectorD& d, const VectorLLD& lld, + const fortran_int_t ifirst, const fortran_int_t ilast, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type rtol1, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type rtol2, + const fortran_int_t offset, VectorW& w, VectorWGAP& wgap, + VectorWERR& werr, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type pivmin, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type spdiam, const fortran_int_t twist ) { + return larrb_impl< typename bindings::value_type< + VectorD >::type >::invoke( n, d, lld, ifirst, ilast, rtol1, rtol2, + offset, w, wgap, werr, pivmin, spdiam, twist, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larre.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larre.hpp new file mode 100644 index 0000000..003a5fd --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larre.hpp @@ -0,0 +1,332 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRE_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARRE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larre is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t larre( const char range, const fortran_int_t n, + float& vl, float& vu, const fortran_int_t il, const fortran_int_t iu, + float* d, float* e, float* e2, const float rtol1, const float rtol2, + const float spltol, fortran_int_t& nsplit, fortran_int_t* isplit, + fortran_int_t& m, float* w, float* werr, float* wgap, + fortran_int_t* iblock, fortran_int_t* indexw, float* gers, + float& pivmin, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SLARRE( &range, &n, &vl, &vu, &il, &iu, d, e, e2, &rtol1, &rtol2, + &spltol, &nsplit, isplit, &m, w, werr, wgap, iblock, indexw, gers, + &pivmin, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t larre( const char range, const fortran_int_t n, + double& vl, double& vu, const fortran_int_t il, + const fortran_int_t iu, double* d, double* e, double* e2, + const double rtol1, const double rtol2, const double spltol, + fortran_int_t& nsplit, fortran_int_t* isplit, fortran_int_t& m, + double* w, double* werr, double* wgap, fortran_int_t* iblock, + fortran_int_t* indexw, double* gers, double& pivmin, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DLARRE( &range, &n, &vl, &vu, &il, &iu, d, e, e2, &rtol1, &rtol2, + &spltol, &nsplit, isplit, &m, w, werr, wgap, iblock, indexw, gers, + &pivmin, work, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larre. +// +template< typename Value > +struct larre_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorISPLIT, typename VectorW, typename VectorWERR, + typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW, + typename VectorGERS, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char range, const fortran_int_t n, + real_type& vl, real_type& vu, const fortran_int_t il, + const fortran_int_t iu, VectorD& d, VectorE& e, VectorE2& e2, + const real_type rtol1, const real_type rtol2, + const real_type spltol, fortran_int_t& nsplit, + VectorISPLIT& isplit, fortran_int_t& m, VectorW& w, + VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock, + VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWGAP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorGERS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorISPLIT >::type >::type, + typename remove_const< typename bindings::value_type< + VectorIBLOCK >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorISPLIT >::type >::type, + typename remove_const< typename bindings::value_type< + VectorINDEXW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE2 >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISPLIT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWGAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIBLOCK >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorINDEXW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorGERS >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n ); + BOOST_ASSERT( bindings::size(e2) >= n ); + BOOST_ASSERT( bindings::size(gers) >= 2*n ); + BOOST_ASSERT( bindings::size(indexw) >= n ); + BOOST_ASSERT( bindings::size(isplit) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(werr) >= n ); + BOOST_ASSERT( bindings::size(wgap) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::larre( range, n, vl, vu, il, iu, + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(e2), rtol1, rtol2, spltol, nsplit, + bindings::begin_value(isplit), m, bindings::begin_value(w), + bindings::begin_value(werr), bindings::begin_value(wgap), + bindings::begin_value(iblock), bindings::begin_value(indexw), + bindings::begin_value(gers), pivmin, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorISPLIT, typename VectorW, typename VectorWERR, + typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW, + typename VectorGERS > + static std::ptrdiff_t invoke( const char range, const fortran_int_t n, + real_type& vl, real_type& vu, const fortran_int_t il, + const fortran_int_t iu, VectorD& d, VectorE& e, VectorE2& e2, + const real_type rtol1, const real_type rtol2, + const real_type spltol, fortran_int_t& nsplit, + VectorISPLIT& isplit, fortran_int_t& m, VectorW& w, + VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock, + VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, + spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, + gers, pivmin, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorISPLIT, typename VectorW, typename VectorWERR, + typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW, + typename VectorGERS > + static std::ptrdiff_t invoke( const char range, const fortran_int_t n, + real_type& vl, real_type& vu, const fortran_int_t il, + const fortran_int_t iu, VectorD& d, VectorE& e, VectorE2& e2, + const real_type rtol1, const real_type rtol2, + const real_type spltol, fortran_int_t& nsplit, + VectorISPLIT& isplit, fortran_int_t& m, VectorW& w, + VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock, + VectorINDEXW& indexw, VectorGERS& gers, real_type& pivmin, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, + spltol, nsplit, isplit, m, w, werr, wgap, iblock, indexw, + gers, pivmin, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 6*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larre_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larre. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorISPLIT, typename VectorW, typename VectorWERR, + typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW, + typename VectorGERS, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larre( const char range, const fortran_int_t n, + typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type& vl, typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type& vu, + const fortran_int_t il, const fortran_int_t iu, VectorD& d, + VectorE& e, VectorE2& e2, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type rtol1, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type rtol2, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type spltol, + fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m, + VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock, + VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type& pivmin, + Workspace work ) { + return larre_impl< typename bindings::value_type< + VectorD >::type >::invoke( range, n, vl, vu, il, iu, d, e, e2, + rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, + indexw, gers, pivmin, work ); +} + +// +// Overloaded function for larre. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorE2, + typename VectorISPLIT, typename VectorW, typename VectorWERR, + typename VectorWGAP, typename VectorIBLOCK, typename VectorINDEXW, + typename VectorGERS > +inline typename boost::disable_if< detail::is_workspace< VectorGERS >, + std::ptrdiff_t >::type +larre( const char range, const fortran_int_t n, + typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type& vl, typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type& vu, + const fortran_int_t il, const fortran_int_t iu, VectorD& d, + VectorE& e, VectorE2& e2, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type rtol1, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type rtol2, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type spltol, + fortran_int_t& nsplit, VectorISPLIT& isplit, fortran_int_t& m, + VectorW& w, VectorWERR& werr, VectorWGAP& wgap, VectorIBLOCK& iblock, + VectorINDEXW& indexw, VectorGERS& gers, typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type& pivmin ) { + return larre_impl< typename bindings::value_type< + VectorD >::type >::invoke( range, n, vl, vu, il, iu, d, e, e2, + rtol1, rtol2, spltol, nsplit, isplit, m, w, werr, wgap, iblock, + indexw, gers, pivmin, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/larz.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/larz.hpp new file mode 100644 index 0000000..91cedfb --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/larz.hpp @@ -0,0 +1,370 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LARZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for larz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t larz( const Side, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t l, const float* v, + const fortran_int_t incv, const float tau, float* c, + const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau, + c, &ldc, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t larz( const Side, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t l, const double* v, + const fortran_int_t incv, const double tau, double* c, + const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau, + c, &ldc, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t larz( const Side, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t l, + const std::complex* v, const fortran_int_t incv, + const std::complex tau, std::complex* c, + const fortran_int_t ldc, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau, + c, &ldc, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t larz( const Side, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t l, + const std::complex* v, const fortran_int_t incv, + const std::complex tau, std::complex* c, + const fortran_int_t ldc, std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZLARZ( &lapack_option< Side >::value, &m, &n, &l, v, &incv, &tau, + c, &ldc, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to larz. +// +template< typename Value, typename Enable = void > +struct larz_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct larz_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorV, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t l, + const VectorV& v, const real_type tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::larz( side, bindings::size_row(c), + bindings::size_column(c), l, bindings::begin_value(v), + bindings::stride(v), tau, bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t l, + const VectorV& v, const real_type tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, l, v, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t l, + const VectorV& v, const real_type tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, l, v, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct larz_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorV, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t l, + const VectorV& v, const value_type tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorV >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::larz( side, bindings::size_row(c), + bindings::size_column(c), l, bindings::begin_value(v), + bindings::stride(v), tau, bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t l, + const VectorV& v, const value_type tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, l, v, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorV, typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t l, + const VectorV& v, const value_type tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, l, v, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the larz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for larz. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorV, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larz( const Side side, const fortran_int_t l, const VectorV& v, + const typename remove_imaginary< typename bindings::value_type< + VectorV >::type >::type tau, MatrixC& c, Workspace work ) { + return larz_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, l, v, tau, c, work ); +} + +// +// Overloaded function for larz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorV, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larz( const Side side, const fortran_int_t l, const VectorV& v, + const typename remove_imaginary< typename bindings::value_type< + VectorV >::type >::type tau, MatrixC& c ) { + return larz_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, l, v, tau, c, + optimal_workspace() ); +} + +// +// Overloaded function for larz. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorV, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +larz( const Side side, const fortran_int_t l, const VectorV& v, + const typename bindings::value_type< VectorV >::type tau, MatrixC& c, + Workspace work ) { + return larz_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, l, v, tau, c, work ); +} + +// +// Overloaded function for larz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorV, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +larz( const Side side, const fortran_int_t l, const VectorV& v, + const typename bindings::value_type< VectorV >::type tau, + MatrixC& c ) { + return larz_impl< typename bindings::value_type< + VectorV >::type >::invoke( side, l, v, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/latrd.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/latrd.hpp new file mode 100644 index 0000000..0ac7d40 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/latrd.hpp @@ -0,0 +1,251 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LATRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LATRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for latrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t latrd( const UpLo, const fortran_int_t n, + const fortran_int_t nb, float* a, const fortran_int_t lda, float* e, + float* tau, float* w, const fortran_int_t ldw ) { + fortran_int_t info(0); + LAPACK_SLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w, + &ldw ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t latrd( const UpLo, const fortran_int_t n, + const fortran_int_t nb, double* a, const fortran_int_t lda, double* e, + double* tau, double* w, const fortran_int_t ldw ) { + fortran_int_t info(0); + LAPACK_DLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w, + &ldw ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t latrd( const UpLo, const fortran_int_t n, + const fortran_int_t nb, std::complex* a, + const fortran_int_t lda, float* e, std::complex* tau, + std::complex* w, const fortran_int_t ldw ) { + fortran_int_t info(0); + LAPACK_CLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w, + &ldw ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t latrd( const UpLo, const fortran_int_t n, + const fortran_int_t nb, std::complex* a, + const fortran_int_t lda, double* e, std::complex* tau, + std::complex* w, const fortran_int_t ldw ) { + fortran_int_t info(0); + LAPACK_ZLATRD( &lapack_option< UpLo >::value, &n, &nb, a, &lda, e, tau, w, + &ldw ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to latrd. +// +template< typename Value, typename Enable = void > +struct latrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct latrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorE, typename VectorTAU, + typename MatrixW > + static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a, + VectorE& e, VectorTAU& tau, MatrixW& w ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixW >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixW >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(w) == 1 || + bindings::stride_minor(w) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(w) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::latrd( uplo(), bindings::size_column(a), nb, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(e), bindings::begin_value(tau), + bindings::begin_value(w), bindings::stride_major(w) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct latrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorE, typename VectorTAU, + typename MatrixW > + static std::ptrdiff_t invoke( const fortran_int_t nb, MatrixA& a, + VectorE& e, VectorTAU& tau, MatrixW& w ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixW >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixW >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(w) == 1 || + bindings::stride_minor(w) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(w) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::latrd( uplo(), bindings::size_column(a), nb, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(e), bindings::begin_value(tau), + bindings::begin_value(w), bindings::stride_major(w) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the latrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for latrd. Its overload differs for +// +template< typename MatrixA, typename VectorE, typename VectorTAU, + typename MatrixW > +inline std::ptrdiff_t latrd( const fortran_int_t nb, MatrixA& a, + VectorE& e, VectorTAU& tau, MatrixW& w ) { + return latrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( nb, a, e, tau, w ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/latrs.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/latrs.hpp new file mode 100644 index 0000000..948138c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/latrs.hpp @@ -0,0 +1,244 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LATRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LATRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for latrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans, typename Diag > +inline std::ptrdiff_t latrs( const char uplo, const Trans, const Diag, + const char normin, const fortran_int_t n, const float* a, + const fortran_int_t lda, float* x, float& scale, float* cnorm ) { + fortran_int_t info(0); + LAPACK_SLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option< + Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans, typename Diag > +inline std::ptrdiff_t latrs( const char uplo, const Trans, const Diag, + const char normin, const fortran_int_t n, const double* a, + const fortran_int_t lda, double* x, double& scale, double* cnorm ) { + fortran_int_t info(0); + LAPACK_DLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option< + Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans, typename Diag > +inline std::ptrdiff_t latrs( const char uplo, const Trans, const Diag, + const char normin, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + std::complex* x, float& scale, float* cnorm ) { + fortran_int_t info(0); + LAPACK_CLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option< + Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans, typename Diag > +inline std::ptrdiff_t latrs( const char uplo, const Trans, const Diag, + const char normin, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + std::complex* x, double& scale, double* cnorm ) { + fortran_int_t info(0); + LAPACK_ZLATRS( &uplo, &lapack_option< Trans >::value, &lapack_option< + Diag >::value, &normin, &n, a, &lda, x, &scale, cnorm, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to latrs. +// +template< typename Value, typename Enable = void > +struct latrs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct latrs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorCNORM > + static std::ptrdiff_t invoke( const char uplo, const char normin, + const MatrixA& a, VectorX& x, real_type& scale, + VectorCNORM& cnorm ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename blas::detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorCNORM >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorCNORM >::value) ); + BOOST_ASSERT( bindings::size(x) >= bindings::size_column_op(a, + trans()) ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( normin == 'Y' || normin == 'N' ); + return detail::latrs( uplo, trans(), diag(), normin, + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), scale, + bindings::begin_value(cnorm) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct latrs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorX, typename VectorCNORM > + static std::ptrdiff_t invoke( const char uplo, const char normin, + const MatrixA& a, VectorX& x, real_type& scale, + VectorCNORM& cnorm ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename blas::detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorCNORM >::value) ); + BOOST_ASSERT( bindings::size(x) >= bindings::size_column_op(a, + trans()) ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( normin == 'Y' || normin == 'N' ); + return detail::latrs( uplo, trans(), diag(), normin, + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(x), scale, + bindings::begin_value(cnorm) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the latrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for latrs. Its overload differs for +// +template< typename MatrixA, typename VectorX, typename VectorCNORM > +inline std::ptrdiff_t latrs( const char uplo, const char normin, + const MatrixA& a, VectorX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& scale, + VectorCNORM& cnorm ) { + return latrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( uplo, normin, a, x, scale, cnorm ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/auxiliary/latrz.hpp b/sdk/boost/numeric/bindings/lapack/auxiliary/latrz.hpp new file mode 100644 index 0000000..067933d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/auxiliary/latrz.hpp @@ -0,0 +1,313 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LATRZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_AUXILIARY_LATRZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for latrz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t l, float* a, const fortran_int_t lda, float* tau, + float* work ) { + fortran_int_t info(0); + LAPACK_SLATRZ( &m, &n, &l, a, &lda, tau, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t l, double* a, const fortran_int_t lda, + double* tau, double* work ) { + fortran_int_t info(0); + LAPACK_DLATRZ( &m, &n, &l, a, &lda, tau, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t l, std::complex* a, + const fortran_int_t lda, std::complex* tau, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CLATRZ( &m, &n, &l, a, &lda, tau, work ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t latrz( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t l, std::complex* a, + const fortran_int_t lda, std::complex* tau, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZLATRZ( &m, &n, &l, a, &lda, tau, work ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to latrz. +// +template< typename Value, typename Enable = void > +struct latrz_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct latrz_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::latrz( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( a, tau, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return m; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct latrz_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::latrz( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( a, tau, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return m; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the latrz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for latrz. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +latrz( MatrixA& a, VectorTAU& tau, Workspace work ) { + return latrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for latrz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +latrz( MatrixA& a, VectorTAU& tau ) { + return latrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational.hpp b/sdk/boost/numeric/bindings/lapack/computational.hpp new file mode 100644 index 0000000..d282788 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational.hpp @@ -0,0 +1,174 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/bdsdc.hpp b/sdk/boost/numeric/bindings/lapack/computational/bdsdc.hpp new file mode 100644 index 0000000..eb646c8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/bdsdc.hpp @@ -0,0 +1,256 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_BDSDC_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_BDSDC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for bdsdc is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t bdsdc( const char uplo, const char compq, + const fortran_int_t n, float* d, float* e, float* u, + const fortran_int_t ldu, float* vt, const fortran_int_t ldvt, + float* q, fortran_int_t* iq, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SBDSDC( &uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t bdsdc( const char uplo, const char compq, + const fortran_int_t n, double* d, double* e, double* u, + const fortran_int_t ldu, double* vt, const fortran_int_t ldvt, + double* q, fortran_int_t* iq, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DBDSDC( &uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq, work, + iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to bdsdc. +// +template< typename Value > +struct bdsdc_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixU, + typename MatrixVT, typename VectorQ, typename VectorIQ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char uplo, const char compq, + const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u, + MatrixVT& vt, VectorQ& q, VectorIQ& iq, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIQ >::value) ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( compq, n )); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( compq == 'N' || compq == 'P' || compq == 'I' ); + BOOST_ASSERT( n >= 0 ); + return detail::bdsdc( uplo, compq, n, bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(u), + bindings::stride_major(u), bindings::begin_value(vt), + bindings::stride_major(vt), bindings::begin_value(q), + bindings::begin_value(iq), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixU, + typename MatrixVT, typename VectorQ, typename VectorIQ > + static std::ptrdiff_t invoke( const char uplo, const char compq, + const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u, + MatrixVT& vt, VectorQ& q, VectorIQ& iq, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( compq, + n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( uplo, compq, n, d, e, u, vt, q, iq, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixU, + typename MatrixVT, typename VectorQ, typename VectorIQ > + static std::ptrdiff_t invoke( const char uplo, const char compq, + const fortran_int_t n, VectorD& d, VectorE& e, MatrixU& u, + MatrixVT& vt, VectorQ& q, VectorIQ& iq, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, compq, n, d, e, u, vt, q, iq, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char compq, + const std::ptrdiff_t n ) { + switch ( compq ) { + case 'N': return 4*n; + case 'P': return 6*n; + case 'I': return 3*n*n + 4*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 8*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the bdsdc_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for bdsdc. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixU, + typename MatrixVT, typename VectorQ, typename VectorIQ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +bdsdc( const char uplo, const char compq, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q, + VectorIQ& iq, Workspace work ) { + return bdsdc_impl< typename bindings::value_type< + VectorD >::type >::invoke( uplo, compq, n, d, e, u, vt, q, iq, + work ); +} + +// +// Overloaded function for bdsdc. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixU, + typename MatrixVT, typename VectorQ, typename VectorIQ > +inline typename boost::disable_if< detail::is_workspace< VectorIQ >, + std::ptrdiff_t >::type +bdsdc( const char uplo, const char compq, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixU& u, MatrixVT& vt, VectorQ& q, + VectorIQ& iq ) { + return bdsdc_impl< typename bindings::value_type< + VectorD >::type >::invoke( uplo, compq, n, d, e, u, vt, q, iq, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/bdsqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/bdsqr.hpp new file mode 100644 index 0000000..88ee85d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/bdsqr.hpp @@ -0,0 +1,401 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_BDSQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_BDSQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for bdsqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t bdsqr( const char uplo, const fortran_int_t n, + const fortran_int_t ncvt, const fortran_int_t nru, + const fortran_int_t ncc, float* d, float* e, float* vt, + const fortran_int_t ldvt, float* u, const fortran_int_t ldu, float* c, + const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c, + &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t bdsqr( const char uplo, const fortran_int_t n, + const fortran_int_t ncvt, const fortran_int_t nru, + const fortran_int_t ncc, double* d, double* e, double* vt, + const fortran_int_t ldvt, double* u, const fortran_int_t ldu, + double* c, const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c, + &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t bdsqr( const char uplo, const fortran_int_t n, + const fortran_int_t ncvt, const fortran_int_t nru, + const fortran_int_t ncc, float* d, float* e, std::complex* vt, + const fortran_int_t ldvt, std::complex* u, + const fortran_int_t ldu, std::complex* c, + const fortran_int_t ldc, float* rwork ) { + fortran_int_t info(0); + LAPACK_CBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c, + &ldc, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t bdsqr( const char uplo, const fortran_int_t n, + const fortran_int_t ncvt, const fortran_int_t nru, + const fortran_int_t ncc, double* d, double* e, + std::complex* vt, const fortran_int_t ldvt, + std::complex* u, const fortran_int_t ldu, + std::complex* c, const fortran_int_t ldc, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZBDSQR( &uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c, + &ldc, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to bdsqr. +// +template< typename Value, typename Enable = void > +struct bdsqr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct bdsqr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n, bindings::size_column(vt), + bindings::size_row(u), bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_column(vt) >= 0 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( bindings::size_row(u) >= 0 ); + BOOST_ASSERT( bindings::stride_major(u) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(u)) ); + BOOST_ASSERT( n >= 0 ); + return detail::bdsqr( uplo, n, bindings::size_column(vt), + bindings::size_row(u), bindings::size_column(c), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(vt), bindings::stride_major(vt), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC > + static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n, + bindings::size_column(vt), bindings::size_row(u), + bindings::size_column(c) ) ); + return invoke( uplo, n, d, e, vt, u, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC > + static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, n, d, e, vt, u, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t ncvt, const std::ptrdiff_t nru, + const std::ptrdiff_t ncc ) { + if ( ncvt == 0 && nru == 0 && ncc == 0 ) + return 2*n; + else + return std::max< std::ptrdiff_t >(1, 4*n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct bdsqr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC, typename RWORK > + static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, + detail::workspace1< RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixVT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixVT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( n, bindings::size_column(vt), + bindings::size_row(u), bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_column(vt) >= 0 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( bindings::size_row(u) >= 0 ); + BOOST_ASSERT( bindings::stride_major(u) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(u)) ); + BOOST_ASSERT( n >= 0 ); + return detail::bdsqr( uplo, n, bindings::size_column(vt), + bindings::size_row(u), bindings::size_column(c), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(vt), bindings::stride_major(vt), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC > + static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( n, + bindings::size_column(vt), bindings::size_row(u), + bindings::size_column(c) ) ); + return invoke( uplo, n, d, e, vt, u, c, workspace( tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC > + static std::ptrdiff_t invoke( const char uplo, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, n, d, e, vt, u, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n, + const std::ptrdiff_t ncvt, const std::ptrdiff_t nru, + const std::ptrdiff_t ncc ) { + if ( ncvt == 0 && nru == 0 && ncc == 0 ) + return 2*n; + else + return std::max< std::ptrdiff_t >(1, 4*n-4); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the bdsqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for bdsqr. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +bdsqr( const char uplo, const fortran_int_t n, VectorD& d, + VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c, Workspace work ) { + return bdsqr_impl< typename bindings::value_type< + MatrixVT >::type >::invoke( uplo, n, d, e, vt, u, c, work ); +} + +// +// Overloaded function for bdsqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixVT, + typename MatrixU, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +bdsqr( const char uplo, const fortran_int_t n, VectorD& d, + VectorE& e, MatrixVT& vt, MatrixU& u, MatrixC& c ) { + return bdsqr_impl< typename bindings::value_type< + MatrixVT >::type >::invoke( uplo, n, d, e, vt, u, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gbbrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/gbbrd.hpp new file mode 100644 index 0000000..3259fb4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gbbrd.hpp @@ -0,0 +1,456 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBBRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBBRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbbrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gbbrd( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ncc, + const fortran_int_t kl, const fortran_int_t ku, float* ab, + const fortran_int_t ldab, float* d, float* e, float* q, + const fortran_int_t ldq, float* pt, const fortran_int_t ldpt, + float* c, const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq, + pt, &ldpt, c, &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gbbrd( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ncc, + const fortran_int_t kl, const fortran_int_t ku, double* ab, + const fortran_int_t ldab, double* d, double* e, double* q, + const fortran_int_t ldq, double* pt, const fortran_int_t ldpt, + double* c, const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq, + pt, &ldpt, c, &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbbrd( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ncc, + const fortran_int_t kl, const fortran_int_t ku, + std::complex* ab, const fortran_int_t ldab, float* d, float* e, + std::complex* q, const fortran_int_t ldq, + std::complex* pt, const fortran_int_t ldpt, + std::complex* c, const fortran_int_t ldc, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq, + pt, &ldpt, c, &ldc, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbbrd( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ncc, + const fortran_int_t kl, const fortran_int_t ku, + std::complex* ab, const fortran_int_t ldab, double* d, + double* e, std::complex* q, const fortran_int_t ldq, + std::complex* pt, const fortran_int_t ldpt, + std::complex* c, const fortran_int_t ldc, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGBBRD( &vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq, + pt, &ldpt, c, &ldc, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbbrd. +// +template< typename Value, typename Enable = void > +struct gbbrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gbbrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC, + typename WORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixPT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixPT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixPT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 ); + BOOST_ASSERT( bindings::size(d) >= std::min< + std::ptrdiff_t >(bindings::size_row(ab), + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::size(e) >= std::min< + std::ptrdiff_t >(bindings::size_row(ab), + bindings::size_column(ab))-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(ab), + bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(pt) == 1 || + bindings::stride_minor(pt) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_row(ab) >= 0 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+ + 1 ); + BOOST_ASSERT( vect == 'N' || vect == 'Q' || vect == 'P' || + vect == 'B' ); + return detail::gbbrd( vect, bindings::size_row(ab), + bindings::size_column(ab), bindings::size_column(c), + bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(pt), bindings::stride_major(pt), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(ab), bindings::size_column(ab) ) ); + return invoke( vect, ab, d, e, q, pt, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( vect, ab, d, e, q, pt, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return 2*std::max< std::ptrdiff_t >(m,n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gbbrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixPT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixPT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixPT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 ); + BOOST_ASSERT( bindings::size(d) >= std::min< + std::ptrdiff_t >(bindings::size_row(ab), + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::size(e) >= std::min< + std::ptrdiff_t >(bindings::size_row(ab), + bindings::size_column(ab))-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_row(ab), + bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(ab), + bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(pt) == 1 || + bindings::stride_minor(pt) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_row(ab) >= 0 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+ + 1 ); + BOOST_ASSERT( vect == 'N' || vect == 'Q' || vect == 'P' || + vect == 'B' ); + return detail::gbbrd( vect, bindings::size_row(ab), + bindings::size_column(ab), bindings::size_column(c), + bindings::bandwidth_lower(ab), bindings::bandwidth_upper(ab), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(pt), bindings::stride_major(pt), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(ab), bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_row(ab), bindings::size_column(ab) ) ); + return invoke( vect, ab, d, e, q, pt, c, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, MatrixPT& pt, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( vect, ab, d, e, q, pt, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(m,n); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(m,n); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbbrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbbrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gbbrd( const char vect, MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, + MatrixPT& pt, MatrixC& c, Workspace work ) { + return gbbrd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, d, e, q, pt, c, work ); +} + +// +// Overloaded function for gbbrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename MatrixPT, typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +gbbrd( const char vect, MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, + MatrixPT& pt, MatrixC& c ) { + return gbbrd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, d, e, q, pt, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gbcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/gbcon.hpp new file mode 100644 index 0000000..1fdbae4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gbcon.hpp @@ -0,0 +1,364 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gbcon( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, const float* ab, + const fortran_int_t ldab, const fortran_int_t* ipiv, + const float anorm, float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gbcon( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, const double* ab, + const fortran_int_t ldab, const fortran_int_t* ipiv, + const double anorm, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbcon( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const std::complex* ab, const fortran_int_t ldab, + const fortran_int_t* ipiv, const float anorm, float& rcond, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond, work, + rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbcon( const char norm, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const std::complex* ab, const fortran_int_t ldab, + const fortran_int_t* ipiv, const double anorm, double& rcond, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGBCON( &norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, &rcond, work, + rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbcon. +// +template< typename Value, typename Enable = void > +struct gbcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gbcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorIPIV, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + 2*bindings::bandwidth_lower(ab)+(bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab))+1 ); + BOOST_ASSERT( (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)) >= 0 ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::gbcon( norm, bindings::size_column(ab), + bindings::bandwidth_lower(ab), (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(ipiv), + anorm, rcond, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorIPIV > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( norm, ab, ipiv, anorm, rcond, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorIPIV > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, ab, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gbcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorIPIV, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + 2*bindings::bandwidth_lower(ab)+(bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab))+1 ); + BOOST_ASSERT( (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)) >= 0 ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::gbcon( norm, bindings::size_column(ab), + bindings::bandwidth_lower(ab), (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(ipiv), + anorm, rcond, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorIPIV > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( norm, ab, ipiv, anorm, rcond, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorIPIV > + static std::ptrdiff_t invoke( const char norm, const MatrixAB& ab, + const VectorIPIV& ipiv, const real_type anorm, real_type& rcond, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, ab, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gbcon( const char norm, const MatrixAB& ab, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type& rcond, + Workspace work ) { + return gbcon_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, ipiv, anorm, rcond, work ); +} + +// +// Overloaded function for gbcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +gbcon( const char norm, const MatrixAB& ab, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type& rcond ) { + return gbcon_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, ab, ipiv, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gbequ.hpp b/sdk/boost/numeric/bindings/lapack/computational/gbequ.hpp new file mode 100644 index 0000000..553c5ac --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gbequ.hpp @@ -0,0 +1,238 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBEQU_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBEQU_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbequ is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gbequ( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, const float* ab, + const fortran_int_t ldab, float* r, float* c, float& rowcnd, + float& colcnd, float& amax ) { + fortran_int_t info(0); + LAPACK_SGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gbequ( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, const double* ab, + const fortran_int_t ldab, double* r, double* c, double& rowcnd, + double& colcnd, double& amax ) { + fortran_int_t info(0); + LAPACK_DGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbequ( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const std::complex* ab, const fortran_int_t ldab, float* r, + float* c, float& rowcnd, float& colcnd, float& amax ) { + fortran_int_t info(0); + LAPACK_CGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbequ( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const std::complex* ab, const fortran_int_t ldab, double* r, + double* c, double& rowcnd, double& colcnd, double& amax ) { + fortran_int_t info(0); + LAPACK_ZGBEQU( &m, &n, &kl, &ku, ab, &ldab, r, c, &rowcnd, &colcnd, &amax, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbequ. +// +template< typename Value, typename Enable = void > +struct gbequ_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gbequ_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorR, typename VectorC > + static std::ptrdiff_t invoke( const MatrixAB& ab, VectorR& r, VectorC& c, + real_type& rowcnd, real_type& colcnd, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_row(ab) >= 0 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+ + 1 ); + return detail::gbequ( bindings::size_row(ab), + bindings::size_column(ab), bindings::bandwidth_lower(ab), + bindings::bandwidth_upper(ab), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(r), + bindings::begin_value(c), rowcnd, colcnd, amax ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gbequ_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorR, typename VectorC > + static std::ptrdiff_t invoke( const MatrixAB& ab, VectorR& r, VectorC& c, + real_type& rowcnd, real_type& colcnd, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_row(ab) >= 0 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower(ab)+bindings::bandwidth_upper(ab)+ + 1 ); + return detail::gbequ( bindings::size_row(ab), + bindings::size_column(ab), bindings::bandwidth_lower(ab), + bindings::bandwidth_upper(ab), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(r), + bindings::begin_value(c), rowcnd, colcnd, amax ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbequ_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbequ. Its overload differs for +// +template< typename MatrixAB, typename VectorR, typename VectorC > +inline std::ptrdiff_t gbequ( const MatrixAB& ab, VectorR& r, VectorC& c, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rowcnd, typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type& colcnd, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& amax ) { + return gbequ_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, r, c, rowcnd, colcnd, amax ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gbrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/gbrfs.hpp new file mode 100644 index 0000000..92df468 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gbrfs.hpp @@ -0,0 +1,499 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbrfs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const float* ab, const fortran_int_t ldab, + const float* afb, const fortran_int_t ldafb, + const fortran_int_t* ipiv, const float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGBRFS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, afb, &ldafb, ipiv, b, &ldb, x, &ldx, ferr, berr, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbrfs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const double* ab, const fortran_int_t ldab, + const double* afb, const fortran_int_t ldafb, + const fortran_int_t* ipiv, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGBRFS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, afb, &ldafb, ipiv, b, &ldb, x, &ldx, ferr, berr, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbrfs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, const std::complex* afb, + const fortran_int_t ldafb, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGBRFS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, afb, &ldafb, ipiv, b, &ldb, x, &ldx, ferr, berr, work, + rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbrfs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, const std::complex* afb, + const fortran_int_t ldafb, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGBRFS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, afb, &ldafb, ipiv, b, &ldb, x, &ldx, ferr, berr, work, + rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbrfs. +// +template< typename Value, typename Enable = void > +struct gbrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gbrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(ab, + trans()) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= + 2*bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())) >= 0 ); + return detail::gbrfs( trans(), bindings::size_column_op(ab, trans()), + bindings::bandwidth_lower_op(ab, trans()), + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())), + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(afb), + bindings::stride_major(afb), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(ab, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(ab, trans()) ) ); + return invoke( ab, afb, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + return invoke( ab, afb, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gbrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(ab, + trans()) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= + 2*bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())) >= 0 ); + return detail::gbrfs( trans(), bindings::size_column_op(ab, trans()), + bindings::bandwidth_lower_op(ab, trans()), + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())), + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(afb), + bindings::stride_major(afb), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(ab, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(ab, trans()) ) ); + return invoke( ab, afb, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + return invoke( ab, afb, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbrfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gbrfs( const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return gbrfs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, afb, ipiv, b, x, ferr, berr, + work ); +} + +// +// Overloaded function for gbrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +gbrfs( const MatrixAB& ab, const MatrixAFB& afb, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return gbrfs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, afb, ipiv, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gbtrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/gbtrf.hpp new file mode 100644 index 0000000..25667e5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gbtrf.hpp @@ -0,0 +1,170 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbtrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gbtrf( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, float* ab, + const fortran_int_t ldab, fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_SGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gbtrf( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, double* ab, + const fortran_int_t ldab, fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_DGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbtrf( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + std::complex* ab, const fortran_int_t ldab, + fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_CGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbtrf( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + std::complex* ab, const fortran_int_t ldab, + fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_ZGBTRF( &m, &n, &kl, &ku, ab, &ldab, ipiv, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbtrf. +// +template< typename Value > +struct gbtrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAB& ab, VectorIPIV& ipiv ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::size(ipiv) >= std::min< + std::ptrdiff_t >(bindings::size_row(ab), + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_row(ab) >= 0 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + 2*bindings::bandwidth_lower(ab)+(bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab))+1 ); + BOOST_ASSERT( (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)) >= 0 ); + return detail::gbtrf( bindings::size_row(ab), + bindings::size_column(ab), bindings::bandwidth_lower(ab), + (bindings::bandwidth_upper(ab)-bindings::bandwidth_lower(ab)), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(ipiv) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbtrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbtrf. Its overload differs for +// +template< typename MatrixAB, typename VectorIPIV > +inline std::ptrdiff_t gbtrf( MatrixAB& ab, VectorIPIV& ipiv ) { + return gbtrf_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, ipiv ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gbtrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/gbtrs.hpp new file mode 100644 index 0000000..42a2b41 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gbtrs.hpp @@ -0,0 +1,195 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GBTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbtrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbtrs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const float* ab, const fortran_int_t ldab, + const fortran_int_t* ipiv, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SGBTRS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbtrs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const double* ab, const fortran_int_t ldab, + const fortran_int_t* ipiv, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DGBTRS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbtrs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CGBTRS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbtrs( const Trans, const fortran_int_t n, + const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZGBTRS( &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, ab, + &ldab, ipiv, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbtrs. +// +template< typename Value > +struct gbtrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixAB& ab, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(ab, + trans()) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + 2*bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())) >= 0 ); + return detail::gbtrs( trans(), bindings::size_column_op(ab, trans()), + bindings::bandwidth_lower_op(ab, trans()), + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())), + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbtrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbtrs. Its overload differs for +// +template< typename MatrixAB, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t gbtrs( const MatrixAB& ab, const VectorIPIV& ipiv, + MatrixB& b ) { + return gbtrs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gebak.hpp b/sdk/boost/numeric/bindings/lapack/computational/gebak.hpp new file mode 100644 index 0000000..25ee911 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gebak.hpp @@ -0,0 +1,222 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBAK_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBAK_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gebak is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t gebak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, const float* scale, + const fortran_int_t m, float* v, const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_SGEBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, scale, + &m, v, &ldv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t gebak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, const double* scale, + const fortran_int_t m, double* v, const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_DGEBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, scale, + &m, v, &ldv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t gebak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, const float* scale, + const fortran_int_t m, std::complex* v, + const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_CGEBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, scale, + &m, v, &ldv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t gebak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, const double* scale, + const fortran_int_t m, std::complex* v, + const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_ZGEBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, scale, + &m, v, &ldv, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gebak. +// +template< typename Value, typename Enable = void > +struct gebak_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gebak_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSCALE, typename MatrixV > + static std::ptrdiff_t invoke( const char job, const Side side, + const fortran_int_t ilo, const fortran_int_t ihi, + const VectorSCALE& scale, MatrixV& v ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_ASSERT( bindings::size(scale) >= bindings::size_row(v) ); + BOOST_ASSERT( bindings::size_column(v) >= 0 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(v) >= 0 ); + BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(v)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::gebak( job, side, bindings::size_row(v), ilo, ihi, + bindings::begin_value(scale), bindings::size_column(v), + bindings::begin_value(v), bindings::stride_major(v) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gebak_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSCALE, typename MatrixV > + static std::ptrdiff_t invoke( const char job, const Side side, + const fortran_int_t ilo, const fortran_int_t ihi, + const VectorSCALE& scale, MatrixV& v ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_ASSERT( bindings::size(scale) >= bindings::size_row(v) ); + BOOST_ASSERT( bindings::size_column(v) >= 0 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(v) >= 0 ); + BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(v)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::gebak( job, side, bindings::size_row(v), ilo, ihi, + bindings::begin_value(scale), bindings::size_column(v), + bindings::begin_value(v), bindings::stride_major(v) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gebak_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gebak. Its overload differs for +// +template< typename Side, typename VectorSCALE, typename MatrixV > +inline std::ptrdiff_t gebak( const char job, const Side side, + const fortran_int_t ilo, const fortran_int_t ihi, + const VectorSCALE& scale, MatrixV& v ) { + return gebak_impl< typename bindings::value_type< + MatrixV >::type >::invoke( job, side, ilo, ihi, scale, v ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gebal.hpp b/sdk/boost/numeric/bindings/lapack/computational/gebal.hpp new file mode 100644 index 0000000..ddf4437 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gebal.hpp @@ -0,0 +1,209 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBAL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBAL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gebal is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gebal( const char job, const fortran_int_t n, float* a, + const fortran_int_t lda, fortran_int_t& ilo, fortran_int_t& ihi, + float* scale ) { + fortran_int_t info(0); + LAPACK_SGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gebal( const char job, const fortran_int_t n, double* a, + const fortran_int_t lda, fortran_int_t& ilo, fortran_int_t& ihi, + double* scale ) { + fortran_int_t info(0); + LAPACK_DGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gebal( const char job, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t& ilo, + fortran_int_t& ihi, float* scale ) { + fortran_int_t info(0); + LAPACK_CGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gebal( const char job, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t& ilo, + fortran_int_t& ihi, double* scale ) { + fortran_int_t info(0); + LAPACK_ZGEBAL( &job, &n, a, &lda, &ilo, &ihi, scale, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gebal. +// +template< typename Value, typename Enable = void > +struct gebal_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gebal_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorSCALE > + static std::ptrdiff_t invoke( const char job, MatrixA& a, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorSCALE& scale ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::gebal( job, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), ilo, ihi, + bindings::begin_value(scale) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gebal_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorSCALE > + static std::ptrdiff_t invoke( const char job, MatrixA& a, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorSCALE& scale ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::gebal( job, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), ilo, ihi, + bindings::begin_value(scale) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gebal_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gebal. Its overload differs for +// +template< typename MatrixA, typename VectorSCALE > +inline std::ptrdiff_t gebal( const char job, MatrixA& a, + fortran_int_t& ilo, fortran_int_t& ihi, VectorSCALE& scale ) { + return gebal_impl< typename bindings::value_type< + MatrixA >::type >::invoke( job, a, ilo, ihi, scale ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gebrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/gebrd.hpp new file mode 100644 index 0000000..8b451d5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gebrd.hpp @@ -0,0 +1,391 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEBRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gebrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gebrd( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, float* d, float* e, float* tauq, + float* taup, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gebrd( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, double* d, double* e, + double* tauq, double* taup, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gebrd( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, float* d, float* e, + std::complex* tauq, std::complex* taup, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gebrd( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, double* d, + double* e, std::complex* tauq, std::complex* taup, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGEBRD( &m, &n, a, &lda, d, e, tauq, taup, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gebrd. +// +template< typename Value, typename Enable = void > +struct gebrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gebrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) ); + BOOST_ASSERT( bindings::size(d) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(taup) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(tauq) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gebrd( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tauq), bindings::begin_value(taup), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a) ) ); + return invoke( a, d, e, tauq, taup, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gebrd( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tauq), bindings::begin_value(taup), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, d, e, tauq, taup, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,std::max< std::ptrdiff_t >(m,n)); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gebrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUP >::value) ); + BOOST_ASSERT( bindings::size(d) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(taup) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(tauq) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gebrd( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tauq), bindings::begin_value(taup), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a) ) ); + return invoke( a, d, e, tauq, taup, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAUQ& tauq, VectorTAUP& taup, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::gebrd( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tauq), bindings::begin_value(taup), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, d, e, tauq, taup, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,std::max< std::ptrdiff_t >(m,n)); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gebrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gebrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gebrd( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq, + VectorTAUP& taup, Workspace work ) { + return gebrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tauq, taup, work ); +} + +// +// Overloaded function for gebrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAUQ, typename VectorTAUP > +inline typename boost::disable_if< detail::is_workspace< VectorTAUP >, + std::ptrdiff_t >::type +gebrd( MatrixA& a, VectorD& d, VectorE& e, VectorTAUQ& tauq, + VectorTAUP& taup ) { + return gebrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tauq, taup, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gecon.hpp b/sdk/boost/numeric/bindings/lapack/computational/gecon.hpp new file mode 100644 index 0000000..e613feb --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gecon.hpp @@ -0,0 +1,333 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GECON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GECON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gecon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gecon( const char norm, const fortran_int_t n, + const float* a, const fortran_int_t lda, const float anorm, + float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGECON( &norm, &n, a, &lda, &anorm, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gecon( const char norm, const fortran_int_t n, + const double* a, const fortran_int_t lda, const double anorm, + double& rcond, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGECON( &norm, &n, a, &lda, &anorm, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gecon( const char norm, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const float anorm, float& rcond, std::complex* work, + float* rwork ) { + fortran_int_t info(0); + LAPACK_CGECON( &norm, &n, a, &lda, &anorm, &rcond, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gecon( const char norm, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const double anorm, double& rcond, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGECON( &norm, &n, a, &lda, &anorm, &rcond, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gecon. +// +template< typename Value, typename Enable = void > +struct gecon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gecon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + const real_type anorm, real_type& rcond, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::gecon( norm, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), anorm, + rcond, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( norm, a, anorm, rcond, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, a, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 4*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gecon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + const real_type anorm, real_type& rcond, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::gecon( norm, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), anorm, + rcond, bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( norm, a, anorm, rcond, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( norm, a, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gecon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gecon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gecon( const char norm, const MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + Workspace work ) { + return gecon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, anorm, rcond, work ); +} + +// +// Overloaded function for gecon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +gecon( const char norm, const MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond ) { + return gecon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/geequ.hpp b/sdk/boost/numeric/bindings/lapack/computational/geequ.hpp new file mode 100644 index 0000000..26e4005 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/geequ.hpp @@ -0,0 +1,221 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEEQU_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEEQU_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geequ is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geequ( const fortran_int_t m, const fortran_int_t n, + const float* a, const fortran_int_t lda, float* r, float* c, + float& rowcnd, float& colcnd, float& amax ) { + fortran_int_t info(0); + LAPACK_SGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geequ( const fortran_int_t m, const fortran_int_t n, + const double* a, const fortran_int_t lda, double* r, double* c, + double& rowcnd, double& colcnd, double& amax ) { + fortran_int_t info(0); + LAPACK_DGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geequ( const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, float* r, + float* c, float& rowcnd, float& colcnd, float& amax ) { + fortran_int_t info(0); + LAPACK_CGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geequ( const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, double* r, + double* c, double& rowcnd, double& colcnd, double& amax ) { + fortran_int_t info(0); + LAPACK_ZGEEQU( &m, &n, a, &lda, r, c, &rowcnd, &colcnd, &amax, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geequ. +// +template< typename Value, typename Enable = void > +struct geequ_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geequ_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorR, typename VectorC > + static std::ptrdiff_t invoke( const MatrixA& a, VectorR& r, VectorC& c, + real_type& rowcnd, real_type& colcnd, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geequ( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(r), bindings::begin_value(c), rowcnd, + colcnd, amax ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geequ_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorR, typename VectorC > + static std::ptrdiff_t invoke( const MatrixA& a, VectorR& r, VectorC& c, + real_type& rowcnd, real_type& colcnd, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geequ( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(r), bindings::begin_value(c), rowcnd, + colcnd, amax ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geequ_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geequ. Its overload differs for +// +template< typename MatrixA, typename VectorR, typename VectorC > +inline std::ptrdiff_t geequ( const MatrixA& a, VectorR& r, VectorC& c, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rowcnd, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& colcnd, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& amax ) { + return geequ_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, r, c, rowcnd, colcnd, amax ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gehrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/gehrd.hpp new file mode 100644 index 0000000..741d5dd --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gehrd.hpp @@ -0,0 +1,332 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEHRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEHRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gehrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gehrd( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, float* a, const fortran_int_t lda, + float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gehrd( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, double* a, const fortran_int_t lda, + double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gehrd( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* a, + const fortran_int_t lda, std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gehrd( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* a, + const fortran_int_t lda, std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGEHRD( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gehrd. +// +template< typename Value, typename Enable = void > +struct gehrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gehrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::gehrd( bindings::size_column(a), ilo, ihi, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gehrd( bindings::size_column(a), ilo, ihi, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gehrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::gehrd( bindings::size_column(a), ilo, ihi, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::gehrd( bindings::size_column(a), ilo, ihi, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gehrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gehrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gehrd( const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, VectorTAU& tau, Workspace work ) { + return gehrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ilo, ihi, a, tau, work ); +} + +// +// Overloaded function for gehrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +gehrd( const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, VectorTAU& tau ) { + return gehrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ilo, ihi, a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gelqf.hpp b/sdk/boost/numeric/bindings/lapack/computational/gelqf.hpp new file mode 100644 index 0000000..f06cc94 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gelqf.hpp @@ -0,0 +1,330 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GELQF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GELQF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gelqf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gelqf( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGELQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gelqf( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGELQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelqf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGELQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelqf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGELQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gelqf. +// +template< typename Value, typename Enable = void > +struct gelqf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gelqf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gelqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gelqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >(1,m); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gelqf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gelqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::gelqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >(1,m); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gelqf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gelqf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gelqf( MatrixA& a, VectorTAU& tau, Workspace work ) { + return gelqf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for gelqf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +gelqf( MatrixA& a, VectorTAU& tau ) { + return gelqf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/geqlf.hpp b/sdk/boost/numeric/bindings/lapack/computational/geqlf.hpp new file mode 100644 index 0000000..1238a33 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/geqlf.hpp @@ -0,0 +1,330 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQLF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQLF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geqlf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geqlf( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geqlf( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geqlf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geqlf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGEQLF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geqlf. +// +template< typename Value, typename Enable = void > +struct geqlf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geqlf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geqlf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::geqlf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geqlf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geqlf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::geqlf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geqlf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geqlf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geqlf( MatrixA& a, VectorTAU& tau, Workspace work ) { + return geqlf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for geqlf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +geqlf( MatrixA& a, VectorTAU& tau ) { + return geqlf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/geqp3.hpp b/sdk/boost/numeric/bindings/lapack/computational/geqp3.hpp new file mode 100644 index 0000000..b8c34ce --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/geqp3.hpp @@ -0,0 +1,352 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQP3_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQP3_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geqp3 is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geqp3( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, fortran_int_t* jpvt, float* tau, + float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geqp3( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, fortran_int_t* jpvt, double* tau, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geqp3( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* jpvt, + std::complex* tau, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geqp3( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* jpvt, + std::complex* tau, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGEQP3( &m, &n, a, &lda, jpvt, tau, work, &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geqp3. +// +template< typename Value, typename Enable = void > +struct geqp3_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geqp3_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorJPVT, typename VectorTAU, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geqp3( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(jpvt), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorJPVT, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, jpvt, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorJPVT, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::geqp3( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(jpvt), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, jpvt, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n+1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geqp3_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorJPVT, typename VectorTAU, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geqp3( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(jpvt), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorJPVT, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, jpvt, tau, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorJPVT, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::geqp3( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(jpvt), bindings::begin_value(tau), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, jpvt, tau, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n+1; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geqp3_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geqp3. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorJPVT, typename VectorTAU, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geqp3( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau, Workspace work ) { + return geqp3_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, jpvt, tau, work ); +} + +// +// Overloaded function for geqp3. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorJPVT, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +geqp3( MatrixA& a, VectorJPVT& jpvt, VectorTAU& tau ) { + return geqp3_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, jpvt, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/geqrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/geqrf.hpp new file mode 100644 index 0000000..1cc321a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/geqrf.hpp @@ -0,0 +1,330 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GEQRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geqrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geqrf( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geqrf( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geqrf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geqrf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGEQRF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geqrf. +// +template< typename Value, typename Enable = void > +struct geqrf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geqrf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geqrf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::geqrf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geqrf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::geqrf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::geqrf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geqrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geqrf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geqrf( MatrixA& a, VectorTAU& tau, Workspace work ) { + return geqrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for geqrf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +geqrf( MatrixA& a, VectorTAU& tau ) { + return geqrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gerfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/gerfs.hpp new file mode 100644 index 0000000..c9f509f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gerfs.hpp @@ -0,0 +1,469 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GERFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GERFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gerfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gerfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const float* af, const fortran_int_t ldaf, const fortran_int_t* ipiv, + const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGERFS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gerfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const double* af, const fortran_int_t ldaf, const fortran_int_t* ipiv, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGERFS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gerfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGERFS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gerfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGERFS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gerfs. +// +template< typename Value, typename Enable = void > +struct gerfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gerfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(a, + trans()) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::gerfs( trans(), bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()) ) ); + return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gerfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(a, + trans()) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::gerfs( trans(), bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(a, trans()) ) ); + return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gerfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gerfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gerfs( const MatrixA& a, const MatrixAF& af, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return gerfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, ipiv, b, x, ferr, berr, work ); +} + +// +// Overloaded function for gerfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +gerfs( const MatrixA& a, const MatrixAF& af, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return gerfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, ipiv, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gerqf.hpp b/sdk/boost/numeric/bindings/lapack/computational/gerqf.hpp new file mode 100644 index 0000000..d42000b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gerqf.hpp @@ -0,0 +1,330 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GERQF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GERQF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gerqf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gerqf( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGERQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gerqf( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGERQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gerqf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGERQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gerqf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGERQF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gerqf. +// +template< typename Value, typename Enable = void > +struct gerqf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gerqf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gerqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gerqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >(1,m); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gerqf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gerqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::gerqf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >(1,m); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gerqf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gerqf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gerqf( MatrixA& a, VectorTAU& tau, Workspace work ) { + return gerqf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for gerqf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +gerqf( MatrixA& a, VectorTAU& tau ) { + return gerqf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/getrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/getrf.hpp new file mode 100644 index 0000000..27b3fc7 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/getrf.hpp @@ -0,0 +1,228 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for getrf is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const int m, const int n, float* a, + const int lda, int* ipiv ) { + return clapack_sgetrf( clapack_option< Order >::value, m, n, a, lda, + ipiv ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const int m, const int n, double* a, + const int lda, int* ipiv ) { + return clapack_dgetrf( clapack_option< Order >::value, m, n, a, lda, + ipiv ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const int m, const int n, + std::complex* a, const int lda, int* ipiv ) { + return clapack_cgetrf( clapack_option< Order >::value, m, n, a, lda, + ipiv ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const int m, const int n, + std::complex* a, const int lda, int* ipiv ) { + return clapack_zgetrf( clapack_option< Order >::value, m, n, a, lda, + ipiv ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const fortran_int_t m, + const fortran_int_t n, float* a, const fortran_int_t lda, + fortran_int_t* ipiv ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SGETRF( &m, &n, a, &lda, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const fortran_int_t m, + const fortran_int_t n, double* a, const fortran_int_t lda, + fortran_int_t* ipiv ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DGETRF( &m, &n, a, &lda, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const fortran_int_t m, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CGETRF( &m, &n, a, &lda, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getrf( Order, const fortran_int_t m, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZGETRF( &m, &n, a, &lda, ipiv, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to getrf. +// +template< typename Value > +struct getrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::getrf( order(), bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the getrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for getrf. Its overload differs for +// +template< typename MatrixA, typename VectorIPIV > +inline std::ptrdiff_t getrf( MatrixA& a, VectorIPIV& ipiv ) { + return getrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/getri.hpp b/sdk/boost/numeric/bindings/lapack/computational/getri.hpp new file mode 100644 index 0000000..3bc5e7e --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/getri.hpp @@ -0,0 +1,399 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for getri is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const int n, float* a, const int lda, + const int* ipiv, float* work, const int lwork ) { + return clapack_sgetri( clapack_option< Order >::value, n, a, lda, ipiv ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const int n, double* a, const int lda, + const int* ipiv, double* work, const int lwork ) { + return clapack_dgetri( clapack_option< Order >::value, n, a, lda, ipiv ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const int n, std::complex* a, + const int lda, const int* ipiv, std::complex* work, + const int lwork ) { + return clapack_cgetri( clapack_option< Order >::value, n, a, lda, ipiv ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const int n, std::complex* a, + const int lda, const int* ipiv, std::complex* work, + const int lwork ) { + return clapack_zgetri( clapack_option< Order >::value, n, a, lda, ipiv ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const fortran_int_t n, float* a, + const fortran_int_t lda, const fortran_int_t* ipiv, float* work, + const fortran_int_t lwork ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SGETRI( &n, a, &lda, ipiv, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const fortran_int_t n, double* a, + const fortran_int_t lda, const fortran_int_t* ipiv, double* work, + const fortran_int_t lwork ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DGETRI( &n, a, &lda, ipiv, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, std::complex* work, + const fortran_int_t lwork ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CGETRI( &n, a, &lda, ipiv, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t getri( Order, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, std::complex* work, + const fortran_int_t lwork ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZGETRI( &n, a, &lda, ipiv, work, &lwork, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to getri. +// +template< typename Value, typename Enable = void > +struct getri_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct getri_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::getri( order(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK + bindings::detail::array< real_type > tmp_work( 0 ); +#else + real_type opt_size_work; + detail::getri( order(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); +#endif + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK + return 0; +#else + return std::max< std::ptrdiff_t >(1,n); +#endif + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct getri_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::getri( order(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK + bindings::detail::array< value_type > tmp_work( 0 ); +#else + value_type opt_size_work; + detail::getri( order(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); +#endif + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK + return 0; +#else + return std::max< std::ptrdiff_t >(1,n); +#endif + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the getri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for getri. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +getri( MatrixA& a, const VectorIPIV& ipiv, Workspace work ) { + return getri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, work ); +} + +// +// Overloaded function for getri. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +getri( MatrixA& a, const VectorIPIV& ipiv ) { + return getri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/getrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/getrs.hpp new file mode 100644 index 0000000..a88ee67 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/getrs.hpp @@ -0,0 +1,255 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GETRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for getrs is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const int n, const int nrhs, + const float* a, const int lda, const int* ipiv, float* b, + const int ldb ) { + return clapack_sgetrs + ( clapack_option< Order >::value, clapack_option< Trans >::value, n, nrhs, + a, lda, ipiv, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const int n, const int nrhs, + const double* a, const int lda, const int* ipiv, double* b, + const int ldb ) { + return clapack_dgetrs + ( clapack_option< Order >::value, clapack_option< Trans >::value, n, nrhs, + a, lda, ipiv, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const int n, const int nrhs, + const std::complex* a, const int lda, const int* ipiv, + std::complex* b, const int ldb ) { + return clapack_cgetrs + ( clapack_option< Order >::value, clapack_option< Trans >::value, n, nrhs, + a, lda, ipiv, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const int n, const int nrhs, + const std::complex* a, const int lda, const int* ipiv, + std::complex* b, const int ldb ) { + return clapack_zgetrs + ( clapack_option< Order >::value, clapack_option< Trans >::value, n, nrhs, + a, lda, ipiv, b, ldb ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const fortran_int_t* ipiv, float* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SGETRS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, ipiv, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const fortran_int_t* ipiv, double* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DGETRS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, ipiv, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CGETRS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, ipiv, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename Trans > +inline std::ptrdiff_t getrs( Order, const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZGETRS( &lapack_option< Trans >::value, &n, &nrhs, a, &lda, ipiv, + b, &ldb, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to getrs. +// +template< typename Value > +struct getrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(a, + trans()) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::getrs( order(), trans(), bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the getrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for getrs. Its overload differs for +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t getrs( const MatrixA& a, const VectorIPIV& ipiv, + MatrixB& b ) { + return getrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ggbak.hpp b/sdk/boost/numeric/bindings/lapack/computational/ggbak.hpp new file mode 100644 index 0000000..35f2dc1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ggbak.hpp @@ -0,0 +1,242 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGBAK_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGBAK_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggbak is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t ggbak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, const float* lscale, + const float* rscale, const fortran_int_t m, float* v, + const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_SGGBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, + lscale, rscale, &m, v, &ldv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t ggbak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + const double* lscale, const double* rscale, const fortran_int_t m, + double* v, const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_DGGBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, + lscale, rscale, &m, v, &ldv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t ggbak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, const float* lscale, + const float* rscale, const fortran_int_t m, std::complex* v, + const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_CGGBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, + lscale, rscale, &m, v, &ldv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t ggbak( const char job, const Side, const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + const double* lscale, const double* rscale, const fortran_int_t m, + std::complex* v, const fortran_int_t ldv ) { + fortran_int_t info(0); + LAPACK_ZGGBAK( &job, &lapack_option< Side >::value, &n, &ilo, &ihi, + lscale, rscale, &m, v, &ldv, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggbak. +// +template< typename Value, typename Enable = void > +struct ggbak_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggbak_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorLSCALE, typename VectorRSCALE, + typename MatrixV > + static std::ptrdiff_t invoke( const char job, const Side side, + const fortran_int_t ilo, const fortran_int_t ihi, + const VectorLSCALE& lscale, const VectorRSCALE& rscale, + MatrixV& v ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_ASSERT( bindings::size(lscale) >= bindings::size_row(v) ); + BOOST_ASSERT( bindings::size(rscale) >= bindings::size_row(v) ); + BOOST_ASSERT( bindings::size_column(v) >= 0 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(v) >= 0 ); + BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(v)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::ggbak( job, side, bindings::size_row(v), ilo, ihi, + bindings::begin_value(lscale), bindings::begin_value(rscale), + bindings::size_column(v), bindings::begin_value(v), + bindings::stride_major(v) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggbak_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorLSCALE, typename VectorRSCALE, + typename MatrixV > + static std::ptrdiff_t invoke( const char job, const Side side, + const fortran_int_t ilo, const fortran_int_t ihi, + const VectorLSCALE& lscale, const VectorRSCALE& rscale, + MatrixV& v ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_ASSERT( bindings::size(lscale) >= bindings::size_row(v) ); + BOOST_ASSERT( bindings::size(rscale) >= bindings::size_row(v) ); + BOOST_ASSERT( bindings::size_column(v) >= 0 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(v) >= 0 ); + BOOST_ASSERT( bindings::stride_major(v) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(v)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::ggbak( job, side, bindings::size_row(v), ilo, ihi, + bindings::begin_value(lscale), bindings::begin_value(rscale), + bindings::size_column(v), bindings::begin_value(v), + bindings::stride_major(v) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggbak_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggbak. Its overload differs for +// +template< typename Side, typename VectorLSCALE, typename VectorRSCALE, + typename MatrixV > +inline std::ptrdiff_t ggbak( const char job, const Side side, + const fortran_int_t ilo, const fortran_int_t ihi, + const VectorLSCALE& lscale, const VectorRSCALE& rscale, MatrixV& v ) { + return ggbak_impl< typename bindings::value_type< + MatrixV >::type >::invoke( job, side, ilo, ihi, lscale, rscale, + v ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ggbal.hpp b/sdk/boost/numeric/bindings/lapack/computational/ggbal.hpp new file mode 100644 index 0000000..fe20575 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ggbal.hpp @@ -0,0 +1,376 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGBAL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGBAL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggbal is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + fortran_int_t& ilo, fortran_int_t& ihi, float* lscale, float* rscale, + float* work ) { + fortran_int_t info(0); + LAPACK_SGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + fortran_int_t& ilo, fortran_int_t& ihi, double* lscale, + double* rscale, double* work ) { + fortran_int_t info(0); + LAPACK_DGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, fortran_int_t& ilo, + fortran_int_t& ihi, float* lscale, float* rscale, float* work ) { + fortran_int_t info(0); + LAPACK_CGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggbal( const char job, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, fortran_int_t& ilo, + fortran_int_t& ihi, double* lscale, double* rscale, double* work ) { + fortran_int_t info(0); + LAPACK_ZGGBAL( &job, &n, a, &lda, b, &ldb, &ilo, &ihi, lscale, rscale, + work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggbal. +// +template< typename Value, typename Enable = void > +struct ggbal_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggbal_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE, typename WORK > + static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorLSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( job, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::ggbal( job, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), ilo, ihi, + bindings::begin_value(lscale), bindings::begin_value(rscale), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE > + static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( job, + bindings::size_column(a) ) ); + return invoke( job, a, b, ilo, ihi, lscale, rscale, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE > + static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( job, a, b, ilo, ihi, lscale, rscale, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, + const std::ptrdiff_t n ) { + if ( job == 'S' || job == 'B' ) + return std::max< std::ptrdiff_t >(1, 6*n); + else // if ( job == 'N' || job == 'P' ) + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggbal_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE, typename WORK > + static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( job, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( job == 'N' || job == 'P' || job == 'S' || job == 'B' ); + return detail::ggbal( job, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), ilo, ihi, + bindings::begin_value(lscale), bindings::begin_value(rscale), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE > + static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( job, + bindings::size_column(a) ) ); + return invoke( job, a, b, ilo, ihi, lscale, rscale, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE > + static std::ptrdiff_t invoke( const char job, MatrixA& a, MatrixB& b, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( job, a, b, ilo, ihi, lscale, rscale, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, + const std::ptrdiff_t n ) { + if ( job == 'S' || job == 'B' ) + return std::max< std::ptrdiff_t >(1, 6*n); + else // if ( job == 'N' || job == 'P' ) + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggbal_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggbal. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggbal( const char job, MatrixA& a, MatrixB& b, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale, + Workspace work ) { + return ggbal_impl< typename bindings::value_type< + MatrixA >::type >::invoke( job, a, b, ilo, ihi, lscale, rscale, + work ); +} + +// +// Overloaded function for ggbal. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorLSCALE, + typename VectorRSCALE > +inline typename boost::disable_if< detail::is_workspace< VectorRSCALE >, + std::ptrdiff_t >::type +ggbal( const char job, MatrixA& a, MatrixB& b, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale ) { + return ggbal_impl< typename bindings::value_type< + MatrixA >::type >::invoke( job, a, b, ilo, ihi, lscale, rscale, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gghrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/gghrd.hpp new file mode 100644 index 0000000..91d4671 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gghrd.hpp @@ -0,0 +1,209 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGHRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGHRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gghrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gghrd( const char compq, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* q, const fortran_int_t ldq, float* z, + const fortran_int_t ldz ) { + fortran_int_t info(0); + LAPACK_SGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq, + z, &ldz, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gghrd( const char compq, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* q, + const fortran_int_t ldq, double* z, const fortran_int_t ldz ) { + fortran_int_t info(0); + LAPACK_DGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq, + z, &ldz, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gghrd( const char compq, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* q, + const fortran_int_t ldq, std::complex* z, + const fortran_int_t ldz ) { + fortran_int_t info(0); + LAPACK_CGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq, + z, &ldz, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gghrd( const char compq, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* q, + const fortran_int_t ldq, std::complex* z, + const fortran_int_t ldz ) { + fortran_int_t info(0); + LAPACK_ZGGHRD( &compq, &compz, &n, &ilo, &ihi, a, &lda, b, &ldb, q, &ldq, + z, &ldz, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gghrd. +// +template< typename Value > +struct gghrd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > + static std::ptrdiff_t invoke( const char compq, const char compz, + const fortran_int_t ilo, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + return detail::gghrd( compq, compz, bindings::size_column(a), ilo, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(z), + bindings::stride_major(z) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gghrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gghrd. Its overload differs for +// +template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > +inline std::ptrdiff_t gghrd( const char compq, const char compz, + const fortran_int_t ilo, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z ) { + return gghrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( compq, compz, ilo, a, b, q, z ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ggqrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/ggqrf.hpp new file mode 100644 index 0000000..838f097 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ggqrf.hpp @@ -0,0 +1,403 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGQRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGQRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggqrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggqrf( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, float* a, const fortran_int_t lda, float* taua, + float* b, const fortran_int_t ldb, float* taub, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggqrf( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, double* a, const fortran_int_t lda, + double* taua, double* b, const fortran_int_t ldb, double* taub, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggqrf( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, std::complex* a, + const fortran_int_t lda, std::complex* taua, + std::complex* b, const fortran_int_t ldb, + std::complex* taub, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggqrf( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, std::complex* a, + const fortran_int_t lda, std::complex* taua, + std::complex* b, const fortran_int_t ldb, + std::complex* taub, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGGQRF( &n, &m, &p, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggqrf. +// +template< typename Value, typename Enable = void > +struct ggqrf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggqrf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) ); + BOOST_ASSERT( bindings::size(taua) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(taub) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(b)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ggqrf( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ggqrf( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,std::max< std::ptrdiff_t >(n, + std::max< std::ptrdiff_t >(m,p))); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggqrf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) ); + BOOST_ASSERT( bindings::size(taua) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(taub) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(b)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ggqrf( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ggqrf( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,std::max< std::ptrdiff_t >(n, + std::max< std::ptrdiff_t >(m,p))); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggqrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggqrf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggqrf( MatrixA& a, VectorTAUA& taua, MatrixB& b, VectorTAUB& taub, + Workspace work ) { + return ggqrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, taua, b, taub, work ); +} + +// +// Overloaded function for ggqrf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > +inline typename boost::disable_if< detail::is_workspace< VectorTAUB >, + std::ptrdiff_t >::type +ggqrf( MatrixA& a, VectorTAUA& taua, MatrixB& b, VectorTAUB& taub ) { + return ggqrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, taua, b, taub, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ggrqf.hpp b/sdk/boost/numeric/bindings/lapack/computational/ggrqf.hpp new file mode 100644 index 0000000..0721969 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ggrqf.hpp @@ -0,0 +1,403 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGRQF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGRQF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggrqf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggrqf( const fortran_int_t m, const fortran_int_t p, + const fortran_int_t n, float* a, const fortran_int_t lda, float* taua, + float* b, const fortran_int_t ldb, float* taub, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggrqf( const fortran_int_t m, const fortran_int_t p, + const fortran_int_t n, double* a, const fortran_int_t lda, + double* taua, double* b, const fortran_int_t ldb, double* taub, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggrqf( const fortran_int_t m, const fortran_int_t p, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* taua, + std::complex* b, const fortran_int_t ldb, + std::complex* taub, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggrqf( const fortran_int_t m, const fortran_int_t p, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* taua, + std::complex* b, const fortran_int_t ldb, + std::complex* taub, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGGRQF( &m, &p, &n, a, &lda, taua, b, &ldb, taub, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggrqf. +// +template< typename Value, typename Enable = void > +struct ggrqf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggrqf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) ); + BOOST_ASSERT( bindings::size(taua) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(taub) >= std::min< + std::ptrdiff_t >(bindings::size_row(b), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_row(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + return detail::ggrqf( bindings::size_row(a), bindings::size_row(b), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_row(a), + bindings::size_row(b) ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ggrqf( bindings::size_row(a), bindings::size_row(b), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,std::max< std::ptrdiff_t >(n, + std::max< std::ptrdiff_t >(m,p))); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggrqf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAUB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAUB >::value) ); + BOOST_ASSERT( bindings::size(taua) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(taub) >= std::min< + std::ptrdiff_t >(bindings::size_row(b), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_row(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + return detail::ggrqf( bindings::size_row(a), bindings::size_row(b), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_row(a), + bindings::size_row(b) ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAUA& taua, MatrixB& b, + VectorTAUB& taub, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ggrqf( bindings::size_row(a), bindings::size_row(b), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(taua), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(taub), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, taua, b, taub, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,std::max< std::ptrdiff_t >(n, + std::max< std::ptrdiff_t >(m,p))); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggrqf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggrqf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggrqf( MatrixA& a, VectorTAUA& taua, MatrixB& b, VectorTAUB& taub, + Workspace work ) { + return ggrqf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, taua, b, taub, work ); +} + +// +// Overloaded function for ggrqf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAUA, typename MatrixB, + typename VectorTAUB > +inline typename boost::disable_if< detail::is_workspace< VectorTAUB >, + std::ptrdiff_t >::type +ggrqf( MatrixA& a, VectorTAUA& taua, MatrixB& b, VectorTAUB& taub ) { + return ggrqf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, taua, b, taub, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ggsvp.hpp b/sdk/boost/numeric/bindings/lapack/computational/ggsvp.hpp new file mode 100644 index 0000000..c63944c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ggsvp.hpp @@ -0,0 +1,525 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGSVP_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GGSVP_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggsvp is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggsvp( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + float* a, const fortran_int_t lda, float* b, const fortran_int_t ldb, + const float tola, const float tolb, fortran_int_t& k, + fortran_int_t& l, float* u, const fortran_int_t ldu, float* v, + const fortran_int_t ldv, float* q, const fortran_int_t ldq, + fortran_int_t* iwork, float* tau, float* work ) { + fortran_int_t info(0); + LAPACK_SGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb, &tola, + &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, tau, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggsvp( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + double* a, const fortran_int_t lda, double* b, + const fortran_int_t ldb, const double tola, const double tolb, + fortran_int_t& k, fortran_int_t& l, double* u, + const fortran_int_t ldu, double* v, const fortran_int_t ldv, + double* q, const fortran_int_t ldq, fortran_int_t* iwork, double* tau, + double* work ) { + fortran_int_t info(0); + LAPACK_DGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb, &tola, + &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, tau, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggsvp( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, const float tola, + const float tolb, fortran_int_t& k, fortran_int_t& l, + std::complex* u, const fortran_int_t ldu, + std::complex* v, const fortran_int_t ldv, + std::complex* q, const fortran_int_t ldq, fortran_int_t* iwork, + float* rwork, std::complex* tau, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb, &tola, + &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, rwork, tau, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggsvp( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, const double tola, + const double tolb, fortran_int_t& k, fortran_int_t& l, + std::complex* u, const fortran_int_t ldu, + std::complex* v, const fortran_int_t ldv, + std::complex* q, const fortran_int_t ldq, + fortran_int_t* iwork, double* rwork, std::complex* tau, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZGGSVP( &jobu, &jobv, &jobq, &m, &p, &n, a, &lda, b, &ldb, &tola, + &tolb, &k, &l, u, &ldu, v, &ldv, q, &ldq, iwork, rwork, tau, work, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggsvp. +// +template< typename Value, typename Enable = void > +struct ggsvp_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggsvp_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ, typename IWORK, typename TAU, + typename WORK > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, MatrixA& a, MatrixB& b, const real_type tola, + const real_type tolb, fortran_int_t& k, fortran_int_t& l, + MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace3< IWORK, + TAU, WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_tau( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_row(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + BOOST_ASSERT( jobq == 'Q' || jobq == 'N' ); + BOOST_ASSERT( jobu == 'U' || jobu == 'N' ); + BOOST_ASSERT( jobv == 'V' || jobv == 'N' ); + return detail::ggsvp( jobu, jobv, jobq, bindings::size_row(a), + bindings::size_row(b), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), tola, + tolb, k, l, bindings::begin_value(u), + bindings::stride_major(u), bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, MatrixA& a, MatrixB& b, const real_type tola, + const real_type tolb, fortran_int_t& k, fortran_int_t& l, + MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + bindings::detail::array< + real_type > tmp_tau( min_size_tau( bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_row(a), + bindings::size_row(b) ) ); + return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, + workspace( tmp_iwork, tmp_tau, tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, MatrixA& a, MatrixB& b, const real_type tola, + const real_type tolb, fortran_int_t& k, fortran_int_t& l, + MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array tau. + // + static std::ptrdiff_t min_size_tau( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(3*n,std::max< std::ptrdiff_t >(m,p)); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggsvp_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ, typename IWORK, + typename RWORK, typename TAU, typename WORK > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, MatrixA& a, MatrixB& b, const real_type tola, + const real_type tolb, fortran_int_t& k, fortran_int_t& l, + MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace4< IWORK, + RWORK, TAU, WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_tau( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_row(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + BOOST_ASSERT( jobq == 'Q' || jobq == 'N' ); + BOOST_ASSERT( jobu == 'U' || jobu == 'N' ); + BOOST_ASSERT( jobv == 'V' || jobv == 'N' ); + return detail::ggsvp( jobu, jobv, jobq, bindings::size_row(a), + bindings::size_row(b), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), tola, + tolb, k, l, bindings::begin_value(u), + bindings::stride_major(u), bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, MatrixA& a, MatrixB& b, const real_type tola, + const real_type tolb, fortran_int_t& k, fortran_int_t& l, + MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< + value_type > tmp_tau( min_size_tau( bindings::size_column(a) ) ); + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_row(a), + bindings::size_row(b) ) ); + return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, + workspace( tmp_iwork, tmp_rwork, tmp_tau, tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, MatrixA& a, MatrixB& b, const real_type tola, + const real_type tolb, fortran_int_t& k, fortran_int_t& l, + MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobu, jobv, jobq, a, b, tola, tolb, k, l, u, v, q, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array tau. + // + static std::ptrdiff_t min_size_tau( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(3*n,std::max< std::ptrdiff_t >(m,p)); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggsvp_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggsvp. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggsvp( const char jobu, const char jobv, const char jobq, MatrixA& a, + MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type tola, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type tolb, fortran_int_t& k, + fortran_int_t& l, MatrixU& u, MatrixV& v, MatrixQ& q, + Workspace work ) { + return ggsvp_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobv, jobq, a, b, tola, tolb, k, + l, u, v, q, work ); +} + +// +// Overloaded function for ggsvp. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename MatrixU, + typename MatrixV, typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +ggsvp( const char jobu, const char jobv, const char jobq, MatrixA& a, + MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type tola, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type tolb, fortran_int_t& k, + fortran_int_t& l, MatrixU& u, MatrixV& v, MatrixQ& q ) { + return ggsvp_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobv, jobq, a, b, tola, tolb, k, + l, u, v, q, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gtrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/gtrfs.hpp new file mode 100644 index 0000000..d04406e --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gtrfs.hpp @@ -0,0 +1,561 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GTRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GTRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gtrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtrfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const float* dl, const float* d, + const float* du, const float* dlf, const float* df, const float* duf, + const float* du2, const fortran_int_t* ipiv, const float* b, + const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float* ferr, float* berr, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGTRFS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, dlf, + df, duf, du2, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtrfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const double* dl, const double* d, + const double* du, const double* dlf, const double* df, + const double* duf, const double* du2, const fortran_int_t* ipiv, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGTRFS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, dlf, + df, duf, du2, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtrfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* dl, + const std::complex* d, const std::complex* du, + const std::complex* dlf, const std::complex* df, + const std::complex* duf, const std::complex* du2, + const fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGTRFS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, dlf, + df, duf, du2, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtrfs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* dl, + const std::complex* d, const std::complex* du, + const std::complex* dlf, const std::complex* df, + const std::complex* duf, const std::complex* du2, + const fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGTRFS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, dlf, + df, duf, du2, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gtrfs. +// +template< typename Value, typename Enable = void > +struct gtrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gtrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDLF& dlf, const VectorDF& df, + const VectorDUF& duf, const VectorDU2& du2, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDLF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDUF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(df) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(dl) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(dlf) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du2) >= bindings::size_column_op(d, + trans())-2 ); + BOOST_ASSERT( bindings::size(duf) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(d, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + return detail::gtrfs( trans(), bindings::size_column_op(d, trans()), + bindings::size_column(b), bindings::begin_value(dl), + bindings::begin_value(d), bindings::begin_value(du), + bindings::begin_value(dlf), bindings::begin_value(df), + bindings::begin_value(duf), bindings::begin_value(du2), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDLF& dlf, const VectorDF& df, + const VectorDUF& duf, const VectorDU2& du2, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(d, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(d, trans()) ) ); + return invoke( dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDLF& dlf, const VectorDF& df, + const VectorDUF& duf, const VectorDU2& du2, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + return invoke( dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gtrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDLF& dlf, const VectorDF& df, + const VectorDUF& duf, const VectorDU2& du2, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDLF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDUF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(df) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(dl) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(dlf) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du2) >= bindings::size_column_op(d, + trans())-2 ); + BOOST_ASSERT( bindings::size(duf) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(d, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + return detail::gtrfs( trans(), bindings::size_column_op(d, trans()), + bindings::size_column(b), bindings::begin_value(dl), + bindings::begin_value(d), bindings::begin_value(du), + bindings::begin_value(dlf), bindings::begin_value(df), + bindings::begin_value(duf), bindings::begin_value(du2), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDLF& dlf, const VectorDF& df, + const VectorDUF& duf, const VectorDU2& du2, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(d, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(d, trans()) ) ); + return invoke( dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDLF& dlf, const VectorDF& df, + const VectorDUF& duf, const VectorDU2& du2, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + return invoke( dl, d, du, dlf, df, duf, du2, ipiv, b, x, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gtrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gtrfs. Its overload differs for +// * User-defined workspace +// +template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gtrfs( const VectorDL& dl, const VectorD& d, const VectorDU& du, + const VectorDLF& dlf, const VectorDF& df, const VectorDUF& duf, + const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return gtrfs_impl< typename bindings::value_type< + VectorDL >::type >::invoke( dl, d, du, dlf, df, duf, du2, ipiv, b, + x, ferr, berr, work ); +} + +// +// Overloaded function for gtrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +gtrfs( const VectorDL& dl, const VectorD& d, const VectorDU& du, + const VectorDLF& dlf, const VectorDF& df, const VectorDUF& duf, + const VectorDU2& du2, const VectorIPIV& ipiv, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return gtrfs_impl< typename bindings::value_type< + VectorDL >::type >::invoke( dl, d, du, dlf, df, duf, du2, ipiv, b, + x, ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/gttrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/gttrs.hpp new file mode 100644 index 0000000..caa43e1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/gttrs.hpp @@ -0,0 +1,206 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GTTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_GTTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gttrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gttrs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const float* dl, const float* d, + const float* du, const float* du2, const fortran_int_t* ipiv, + float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SGTTRS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, du2, + ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gttrs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const double* dl, const double* d, + const double* du, const double* du2, const fortran_int_t* ipiv, + double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DGTTRS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, du2, + ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gttrs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* dl, + const std::complex* d, const std::complex* du, + const std::complex* du2, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CGTTRS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, du2, + ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gttrs( const Trans, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* dl, + const std::complex* d, const std::complex* du, + const std::complex* du2, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZGTTRS( &lapack_option< Trans >::value, &n, &nrhs, dl, d, du, du2, + ipiv, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gttrs. +// +template< typename Value > +struct gttrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDU2, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDU2& du2, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(dl) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du2) >= bindings::size_column_op(d, + trans())-2 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + return detail::gttrs( trans(), bindings::size_column_op(d, trans()), + bindings::size_column(b), bindings::begin_value(dl), + bindings::begin_value(d), bindings::begin_value(du), + bindings::begin_value(du2), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gttrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gttrs. Its overload differs for +// +template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDU2, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t gttrs( const VectorDL& dl, const VectorD& d, + const VectorDU& du, const VectorDU2& du2, const VectorIPIV& ipiv, + MatrixB& b ) { + return gttrs_impl< typename bindings::value_type< + VectorDL >::type >::invoke( dl, d, du, du2, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hbgst.hpp b/sdk/boost/numeric/bindings/lapack/computational/hbgst.hpp new file mode 100644 index 0000000..9cce0bf --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hbgst.hpp @@ -0,0 +1,383 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HBGST_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HBGST_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbgst is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgst( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + float* ab, const fortran_int_t ldab, const float* bb, + const fortran_int_t ldbb, float* x, const fortran_int_t ldx, + float* work ) { + fortran_int_t info(0); + LAPACK_SSBGST( &vect, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, x, &ldx, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgst( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + double* ab, const fortran_int_t ldab, const double* bb, + const fortran_int_t ldbb, double* x, const fortran_int_t ldx, + double* work ) { + fortran_int_t info(0); + LAPACK_DSBGST( &vect, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, x, &ldx, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgst( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + const std::complex* bb, const fortran_int_t ldbb, + std::complex* x, const fortran_int_t ldx, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHBGST( &vect, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, x, &ldx, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgst( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + const std::complex* bb, const fortran_int_t ldbb, + std::complex* x, const fortran_int_t ldx, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHBGST( &vect, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, x, &ldx, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbgst. +// +template< typename Value, typename Enable = void > +struct hbgst_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbgst_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX, + typename WORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( vect == 'N' || vect == 'V' ); + return detail::hbgst( vect, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(x), + bindings::stride_major(x), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( vect, ab, bb, x, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( vect, ab, bb, x, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbgst_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( vect == 'N' || vect == 'V' ); + return detail::hbgst( vect, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(x), + bindings::stride_major(x), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( vect, ab, bb, x, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( vect, ab, bb, x, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbgst_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbgst. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename MatrixX, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbgst( const char vect, MatrixAB& ab, const MatrixBB& bb, MatrixX& x, + Workspace work ) { + return hbgst_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, bb, x, work ); +} + +// +// Overloaded function for hbgst. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename MatrixX > +inline typename boost::disable_if< detail::is_workspace< MatrixX >, + std::ptrdiff_t >::type +hbgst( const char vect, MatrixAB& ab, const MatrixBB& bb, MatrixX& x ) { + return hbgst_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, bb, x, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hbtrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/hbtrd.hpp new file mode 100644 index 0000000..8284670 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hbtrd.hpp @@ -0,0 +1,370 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HBTRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HBTRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbtrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbtrd( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t kd, float* ab, + const fortran_int_t ldab, float* d, float* e, float* q, + const fortran_int_t ldq, float* work ) { + fortran_int_t info(0); + LAPACK_SSBTRD( &vect, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + d, e, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbtrd( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t kd, double* ab, + const fortran_int_t ldab, double* d, double* e, double* q, + const fortran_int_t ldq, double* work ) { + fortran_int_t info(0); + LAPACK_DSBTRD( &vect, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + d, e, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbtrd( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + std::complex* ab, const fortran_int_t ldab, float* d, float* e, + std::complex* q, const fortran_int_t ldq, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CHBTRD( &vect, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + d, e, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbtrd( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + std::complex* ab, const fortran_int_t ldab, double* d, + double* e, std::complex* q, const fortran_int_t ldq, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZHBTRD( &vect, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + d, e, q, &ldq, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbtrd. +// +template< typename Value, typename Enable = void > +struct hbtrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbtrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename WORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' ); + return detail::hbtrd( vect, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( vect, ab, d, e, q, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( vect, ab, d, e, q, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbtrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename WORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' ); + return detail::hbtrd( vect, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( vect, ab, d, e, q, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( vect, ab, d, e, q, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbtrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbtrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbtrd( const char vect, MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, + Workspace work ) { + return hbtrd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, d, e, q, work ); +} + +// +// Overloaded function for hbtrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +hbtrd( const char vect, MatrixAB& ab, VectorD& d, VectorE& e, + MatrixQ& q ) { + return hbtrd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, d, e, q, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hecon.hpp b/sdk/boost/numeric/bindings/lapack/computational/hecon.hpp new file mode 100644 index 0000000..d88cb8c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hecon.hpp @@ -0,0 +1,338 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HECON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HECON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hecon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hecon( const UpLo, const fortran_int_t n, const float* a, + const fortran_int_t lda, const fortran_int_t* ipiv, const float anorm, + float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSYCON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hecon( const UpLo, const fortran_int_t n, + const double* a, const fortran_int_t lda, const fortran_int_t* ipiv, + const double anorm, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSYCON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hecon( const UpLo, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, const float anorm, float& rcond, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CHECON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hecon( const UpLo, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, const double anorm, double& rcond, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZHECON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hecon. +// +template< typename Value, typename Enable = void > +struct hecon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hecon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hecon( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), anorm, rcond, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( a, ipiv, anorm, rcond, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hecon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hecon( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), anorm, rcond, + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, anorm, rcond, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hecon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hecon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hecon( const MatrixA& a, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + Workspace work ) { + return hecon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, anorm, rcond, work ); +} + +// +// Overloaded function for hecon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +hecon( const MatrixA& a, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond ) { + return hecon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hegst.hpp b/sdk/boost/numeric/bindings/lapack/computational/hegst.hpp new file mode 100644 index 0000000..d00cf65 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hegst.hpp @@ -0,0 +1,179 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HEGST_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HEGST_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hegst is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegst( const fortran_int_t itype, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, + const float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSYGST( &itype, &lapack_option< UpLo >::value, &n, a, &lda, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegst( const fortran_int_t itype, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, + const double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSYGST( &itype, &lapack_option< UpLo >::value, &n, a, &lda, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegst( const fortran_int_t itype, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CHEGST( &itype, &lapack_option< UpLo >::value, &n, a, &lda, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegst( const fortran_int_t itype, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZHEGST( &itype, &lapack_option< UpLo >::value, &n, a, &lda, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hegst. +// +template< typename Value > +struct hegst_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( const fortran_int_t itype, MatrixA& a, + const MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hegst( itype, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hegst_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hegst. Its overload differs for +// +template< typename MatrixA, typename MatrixB > +inline std::ptrdiff_t hegst( const fortran_int_t itype, MatrixA& a, + const MatrixB& b ) { + return hegst_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, a, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/herfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/herfs.hpp new file mode 100644 index 0000000..55eec4a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/herfs.hpp @@ -0,0 +1,464 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HERFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HERFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for herfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t herfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const float* af, const fortran_int_t ldaf, const fortran_int_t* ipiv, + const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSYRFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t herfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const double* af, const fortran_int_t ldaf, const fortran_int_t* ipiv, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSYRFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t herfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHERFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t herfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHERFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to herfs. +// +template< typename Value, typename Enable = void > +struct herfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct herfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::herfs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct herfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::herfs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the herfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for herfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +herfs( const MatrixA& a, const MatrixAF& af, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return herfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, ipiv, b, x, ferr, berr, work ); +} + +// +// Overloaded function for herfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +herfs( const MatrixA& a, const MatrixAF& af, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return herfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, ipiv, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hetrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/hetrd.hpp new file mode 100644 index 0000000..885249d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hetrd.hpp @@ -0,0 +1,368 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hetrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrd( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, float* d, float* e, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYTRD( &lapack_option< UpLo >::value, &n, a, &lda, d, e, tau, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrd( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, double* d, double* e, double* tau, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYTRD( &lapack_option< UpLo >::value, &n, a, &lda, d, e, tau, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrd( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, float* d, float* e, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CHETRD( &lapack_option< UpLo >::value, &n, a, &lda, d, e, tau, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrd( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, double* d, + double* e, std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZHETRD( &lapack_option< UpLo >::value, &n, a, &lda, d, e, tau, + work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hetrd. +// +template< typename Value, typename Enable = void > +struct hetrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hetrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetrd( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work() ); + return invoke( a, d, e, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::hetrd( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, d, e, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hetrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetrd( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work() ); + return invoke( a, d, e, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + detail::hetrd( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, d, e, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hetrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hetrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hetrd( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau, + Workspace work ) { + return hetrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tau, work ); +} + +// +// Overloaded function for hetrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +hetrd( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau ) { + return hetrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hetrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/hetrf.hpp new file mode 100644 index 0000000..bf13fdb --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hetrf.hpp @@ -0,0 +1,325 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hetrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrf( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, fortran_int_t* ipiv, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYTRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrf( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, fortran_int_t* ipiv, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYTRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrf( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* ipiv, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CHETRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrf( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* ipiv, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZHETRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hetrf. +// +template< typename Value, typename Enable = void > +struct hetrf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hetrf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::hetrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hetrf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + detail::hetrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hetrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hetrf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hetrf( MatrixA& a, VectorIPIV& ipiv, Workspace work ) { + return hetrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, work ); +} + +// +// Overloaded function for hetrf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +hetrf( MatrixA& a, VectorIPIV& ipiv ) { + return hetrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hetri.hpp b/sdk/boost/numeric/bindings/lapack/computational/hetri.hpp new file mode 100644 index 0000000..5d58ab5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hetri.hpp @@ -0,0 +1,310 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hetri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetri( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, const fortran_int_t* ipiv, float* work ) { + fortran_int_t info(0); + LAPACK_SSYTRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetri( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, const fortran_int_t* ipiv, double* work ) { + fortran_int_t info(0); + LAPACK_DSYTRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetri( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CHETRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetri( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZHETRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hetri. +// +template< typename Value, typename Enable = void > +struct hetri_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hetri_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetri( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hetri_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetri( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hetri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hetri. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hetri( MatrixA& a, const VectorIPIV& ipiv, Workspace work ) { + return hetri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, work ); +} + +// +// Overloaded function for hetri. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +hetri( MatrixA& a, const VectorIPIV& ipiv ) { + return hetri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hetrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/hetrs.hpp new file mode 100644 index 0000000..1781860 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hetrs.hpp @@ -0,0 +1,182 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HETRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hetrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const fortran_int_t* ipiv, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSYTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const fortran_int_t* ipiv, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSYTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CHETRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hetrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZHETRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hetrs. +// +template< typename Value > +struct hetrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hetrs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hetrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hetrs. Its overload differs for +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t hetrs( const MatrixA& a, const VectorIPIV& ipiv, + MatrixB& b ) { + return hetrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hgeqz.hpp b/sdk/boost/numeric/bindings/lapack/computational/hgeqz.hpp new file mode 100644 index 0000000..d36aede --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hgeqz.hpp @@ -0,0 +1,525 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HGEQZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HGEQZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hgeqz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t hgeqz( const char job, const char compq, + const char compz, const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, float* h, const fortran_int_t ldh, float* t, + const fortran_int_t ldt, float* alphar, float* alphai, float* beta, + float* q, const fortran_int_t ldq, float* z, const fortran_int_t ldz, + float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt, + alphar, alphai, beta, q, &ldq, z, &ldz, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t hgeqz( const char job, const char compq, + const char compz, const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, double* h, const fortran_int_t ldh, + double* t, const fortran_int_t ldt, double* alphar, double* alphai, + double* beta, double* q, const fortran_int_t ldq, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt, + alphar, alphai, beta, q, &ldq, z, &ldz, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t hgeqz( const char job, const char compq, + const char compz, const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* h, + const fortran_int_t ldh, std::complex* t, + const fortran_int_t ldt, std::complex* alpha, + std::complex* beta, std::complex* q, + const fortran_int_t ldq, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt, + alpha, beta, q, &ldq, z, &ldz, work, &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t hgeqz( const char job, const char compq, + const char compz, const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* h, + const fortran_int_t ldh, std::complex* t, + const fortran_int_t ldt, std::complex* alpha, + std::complex* beta, std::complex* q, + const fortran_int_t ldq, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHGEQZ( &job, &compq, &compz, &n, &ilo, &ihi, h, &ldh, t, &ldt, + alpha, beta, q, &ldq, z, &ldz, work, &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hgeqz. +// +template< typename Value, typename Enable = void > +struct hgeqz_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hgeqz_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixH, typename MatrixT, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const char job, const char compq, + const char compz, const fortran_int_t ilo, MatrixH& h, + MatrixT& t, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixQ& q, MatrixZ& z, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size_column(h) >= 0 ); + BOOST_ASSERT( bindings::size_minor(h) == 1 || + bindings::stride_minor(h) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + BOOST_ASSERT( job == 'E' || job == 'S' ); + return detail::hgeqz( job, compq, compz, bindings::size_column(h), + ilo, bindings::size_column(h), bindings::begin_value(h), + bindings::stride_major(h), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(alphar), + bindings::begin_value(alphai), bindings::begin_value(beta), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixH, typename MatrixT, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixQ, + typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compq, + const char compz, const fortran_int_t ilo, MatrixH& h, + MatrixT& t, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixQ& q, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(h) ) ); + return invoke( job, compq, compz, ilo, h, t, alphar, alphai, beta, q, + z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixH, typename MatrixT, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixQ, + typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compq, + const char compz, const fortran_int_t ilo, MatrixH& h, + MatrixT& t, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixQ& q, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::hgeqz( job, compq, compz, bindings::size_column(h), ilo, + bindings::size_column(h), bindings::begin_value(h), + bindings::stride_major(h), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(alphar), + bindings::begin_value(alphai), bindings::begin_value(beta), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( job, compq, compz, ilo, h, t, alphar, alphai, beta, q, + z, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hgeqz_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixH, typename MatrixT, typename VectorALPHA, + typename VectorBETA, typename MatrixQ, typename MatrixZ, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char job, const char compq, + const char compz, const fortran_int_t ilo, MatrixH& h, + MatrixT& t, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, + MatrixZ& z, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size_column(h) >= 0 ); + BOOST_ASSERT( bindings::size_minor(h) == 1 || + bindings::stride_minor(h) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( compq == 'N' || compq == 'I' || compq == 'V' ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + BOOST_ASSERT( job == 'E' || job == 'S' ); + return detail::hgeqz( job, compq, compz, bindings::size_column(h), + ilo, bindings::size_column(h), bindings::begin_value(h), + bindings::stride_major(h), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixH, typename MatrixT, typename VectorALPHA, + typename VectorBETA, typename MatrixQ, typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compq, + const char compz, const fortran_int_t ilo, MatrixH& h, + MatrixT& t, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(h) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(h) ) ); + return invoke( job, compq, compz, ilo, h, t, alpha, beta, q, z, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixH, typename MatrixT, typename VectorALPHA, + typename VectorBETA, typename MatrixQ, typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compq, + const char compz, const fortran_int_t ilo, MatrixH& h, + MatrixT& t, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(h) ) ); + detail::hgeqz( job, compq, compz, bindings::size_column(h), ilo, + bindings::size_column(h), bindings::begin_value(h), + bindings::stride_major(h), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( job, compq, compz, ilo, h, t, alpha, beta, q, z, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hgeqz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hgeqz. Its overload differs for +// * User-defined workspace +// +template< typename MatrixH, typename MatrixT, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hgeqz( const char job, const char compq, const char compz, + const fortran_int_t ilo, MatrixH& h, MatrixT& t, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixQ& q, MatrixZ& z, Workspace work ) { + return hgeqz_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compq, compz, ilo, h, t, alphar, + alphai, beta, q, z, work ); +} + +// +// Overloaded function for hgeqz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixH, typename MatrixT, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixQ, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hgeqz( const char job, const char compq, const char compz, + const fortran_int_t ilo, MatrixH& h, MatrixT& t, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixQ& q, MatrixZ& z ) { + return hgeqz_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compq, compz, ilo, h, t, alphar, + alphai, beta, q, z, optimal_workspace() ); +} + +// +// Overloaded function for hgeqz. Its overload differs for +// * User-defined workspace +// +template< typename MatrixH, typename MatrixT, typename VectorALPHA, + typename VectorBETA, typename MatrixQ, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hgeqz( const char job, const char compq, const char compz, + const fortran_int_t ilo, MatrixH& h, MatrixT& t, + VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z, + Workspace work ) { + return hgeqz_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compq, compz, ilo, h, t, alpha, + beta, q, z, work ); +} + +// +// Overloaded function for hgeqz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixH, typename MatrixT, typename VectorALPHA, + typename VectorBETA, typename MatrixQ, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hgeqz( const char job, const char compq, const char compz, + const fortran_int_t ilo, MatrixH& h, MatrixT& t, + VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z ) { + return hgeqz_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compq, compz, ilo, h, t, alpha, + beta, q, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hpcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/hpcon.hpp new file mode 100644 index 0000000..64e0a55 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hpcon.hpp @@ -0,0 +1,322 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpcon( const UpLo, const fortran_int_t n, + const float* ap, const fortran_int_t* ipiv, const float anorm, + float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpcon( const UpLo, const fortran_int_t n, + const double* ap, const fortran_int_t* ipiv, const double anorm, + double& rcond, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpcon( const UpLo, const fortran_int_t n, + const std::complex* ap, const fortran_int_t* ipiv, + const float anorm, float& rcond, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CHPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpcon( const UpLo, const fortran_int_t n, + const std::complex* ap, const fortran_int_t* ipiv, + const double anorm, double& rcond, std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZHPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpcon. +// +template< typename Value, typename Enable = void > +struct hpcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hpcon( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), anorm, + rcond, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hpcon( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), anorm, + rcond, bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpcon( const MatrixAP& ap, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond, + Workspace work ) { + return hpcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, anorm, rcond, work ); +} + +// +// Overloaded function for hpcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +hpcon( const MatrixAP& ap, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond ) { + return hpcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hprfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/hprfs.hpp new file mode 100644 index 0000000..bd18b6c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hprfs.hpp @@ -0,0 +1,439 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hprfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* ap, const float* afp, + const fortran_int_t* ipiv, const float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* ap, const double* afp, + const fortran_int_t* ipiv, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const std::complex* afp, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const std::complex* afp, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hprfs. +// +template< typename Value, typename Enable = void > +struct hprfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hprfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::hprfs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hprfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::hprfs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hprfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hprfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hprfs( const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return hprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, afp, ipiv, b, x, ferr, berr, + work ); +} + +// +// Overloaded function for hprfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +hprfs( const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return hprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, afp, ipiv, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hptrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/hptrd.hpp new file mode 100644 index 0000000..0c26823 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hptrd.hpp @@ -0,0 +1,226 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hptrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrd( const UpLo, const fortran_int_t n, float* ap, + float* d, float* e, float* tau ) { + fortran_int_t info(0); + LAPACK_SSPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrd( const UpLo, const fortran_int_t n, double* ap, + double* d, double* e, double* tau ) { + fortran_int_t info(0); + LAPACK_DSPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrd( const UpLo, const fortran_int_t n, + std::complex* ap, float* d, float* e, + std::complex* tau ) { + fortran_int_t info(0); + LAPACK_CHPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrd( const UpLo, const fortran_int_t n, + std::complex* ap, double* d, double* e, + std::complex* tau ) { + fortran_int_t info(0); + LAPACK_ZHPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hptrd. +// +template< typename Value, typename Enable = void > +struct hptrd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hptrd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e, + VectorTAU& tau ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(ap)-1 ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hptrd( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(tau) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hptrd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e, + VectorTAU& tau ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(ap)-1 ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hptrd( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(tau) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hptrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hptrd. Its overload differs for +// +template< typename MatrixAP, typename VectorD, typename VectorE, + typename VectorTAU > +inline std::ptrdiff_t hptrd( MatrixAP& ap, VectorD& d, VectorE& e, + VectorTAU& tau ) { + return hptrd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, d, e, tau ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hptrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/hptrf.hpp new file mode 100644 index 0000000..caa40cc --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hptrf.hpp @@ -0,0 +1,152 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hptrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrf( const UpLo, const fortran_int_t n, float* ap, + fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_SSPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrf( const UpLo, const fortran_int_t n, double* ap, + fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_DSPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrf( const UpLo, const fortran_int_t n, + std::complex* ap, fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_CHPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrf( const UpLo, const fortran_int_t n, + std::complex* ap, fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_ZHPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hptrf. +// +template< typename Value > +struct hptrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hptrf( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hptrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hptrf. Its overload differs for +// +template< typename MatrixAP, typename VectorIPIV > +inline std::ptrdiff_t hptrf( MatrixAP& ap, VectorIPIV& ipiv ) { + return hptrf_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hptri.hpp b/sdk/boost/numeric/bindings/lapack/computational/hptri.hpp new file mode 100644 index 0000000..a99fa83 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hptri.hpp @@ -0,0 +1,293 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hptri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptri( const UpLo, const fortran_int_t n, float* ap, + const fortran_int_t* ipiv, float* work ) { + fortran_int_t info(0); + LAPACK_SSPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptri( const UpLo, const fortran_int_t n, double* ap, + const fortran_int_t* ipiv, double* work ) { + fortran_int_t info(0); + LAPACK_DSPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptri( const UpLo, const fortran_int_t n, + std::complex* ap, const fortran_int_t* ipiv, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CHPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptri( const UpLo, const fortran_int_t n, + std::complex* ap, const fortran_int_t* ipiv, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZHPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hptri. +// +template< typename Value, typename Enable = void > +struct hptri_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hptri_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hptri( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( ap, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hptri_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::hptri( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( ap, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hptri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hptri. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hptri( MatrixAP& ap, const VectorIPIV& ipiv, Workspace work ) { + return hptri_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, work ); +} + +// +// Overloaded function for hptri. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +hptri( MatrixAP& ap, const VectorIPIV& ipiv ) { + return hptri_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hptrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/hptrs.hpp new file mode 100644 index 0000000..cb4cd20 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hptrs.hpp @@ -0,0 +1,177 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HPTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hptrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* ap, const fortran_int_t* ipiv, + float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* ap, const fortran_int_t* ipiv, + double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CHPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZHPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hptrs. +// +template< typename Value > +struct hptrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::hptrs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hptrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hptrs. Its overload differs for +// +template< typename MatrixAP, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t hptrs( const MatrixAP& ap, const VectorIPIV& ipiv, + MatrixB& b ) { + return hptrs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hsein.hpp b/sdk/boost/numeric/bindings/lapack/computational/hsein.hpp new file mode 100644 index 0000000..e5a6407 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hsein.hpp @@ -0,0 +1,500 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEIN_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEIN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hsein is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t hsein( const Side, const char eigsrc, const char initv, + fortran_bool_t* select, const fortran_int_t n, const float* h, + const fortran_int_t ldh, float* wr, const float* wi, float* vl, + const fortran_int_t ldvl, float* vr, const fortran_int_t ldvr, + const fortran_int_t mm, fortran_int_t& m, float* work, + fortran_int_t* ifaill, fortran_int_t* ifailr ) { + fortran_int_t info(0); + LAPACK_SHSEIN( &lapack_option< Side >::value, &eigsrc, &initv, select, &n, + h, &ldh, wr, wi, vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, + ifailr, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t hsein( const Side, const char eigsrc, const char initv, + fortran_bool_t* select, const fortran_int_t n, const double* h, + const fortran_int_t ldh, double* wr, const double* wi, double* vl, + const fortran_int_t ldvl, double* vr, const fortran_int_t ldvr, + const fortran_int_t mm, fortran_int_t& m, double* work, + fortran_int_t* ifaill, fortran_int_t* ifailr ) { + fortran_int_t info(0); + LAPACK_DHSEIN( &lapack_option< Side >::value, &eigsrc, &initv, select, &n, + h, &ldh, wr, wi, vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, + ifailr, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t hsein( const Side, const char eigsrc, const char initv, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* h, const fortran_int_t ldh, + std::complex* w, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, const fortran_int_t mm, fortran_int_t& m, + std::complex* work, float* rwork, fortran_int_t* ifaill, + fortran_int_t* ifailr ) { + fortran_int_t info(0); + LAPACK_CHSEIN( &lapack_option< Side >::value, &eigsrc, &initv, select, &n, + h, &ldh, w, vl, &ldvl, vr, &ldvr, &mm, &m, work, rwork, ifaill, + ifailr, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t hsein( const Side, const char eigsrc, const char initv, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* h, const fortran_int_t ldh, + std::complex* w, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, const fortran_int_t mm, fortran_int_t& m, + std::complex* work, double* rwork, fortran_int_t* ifaill, + fortran_int_t* ifailr ) { + fortran_int_t info(0); + LAPACK_ZHSEIN( &lapack_option< Side >::value, &eigsrc, &initv, select, &n, + h, &ldh, w, vl, &ldvl, vr, &ldvr, &mm, &m, work, rwork, ifaill, + ifailr, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hsein. +// +template< typename Value, typename Enable = void > +struct hsein_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hsein_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorWR, typename VectorWI, typename MatrixVL, + typename MatrixVR, typename VectorIFAILL, typename VectorIFAILR, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const char eigsrc, + const char initv, VectorSELECT& select, const MatrixH& h, + VectorWR& wr, const VectorWI& wi, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIFAILL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorIFAILR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSELECT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILR >::value) ); + BOOST_ASSERT( bindings::size(select) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size_column(h) >= 0 ); + BOOST_ASSERT( bindings::size_minor(h) == 1 || + bindings::stride_minor(h) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' ); + BOOST_ASSERT( initv == 'N' || initv == 'U' ); + return detail::hsein( side, eigsrc, initv, + bindings::begin_value(select), bindings::size_column(h), + bindings::begin_value(h), bindings::stride_major(h), + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), mm, m, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(ifaill), bindings::begin_value(ifailr) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorWR, typename VectorWI, typename MatrixVL, + typename MatrixVR, typename VectorIFAILL, typename VectorIFAILR > + static std::ptrdiff_t invoke( const Side side, const char eigsrc, + const char initv, VectorSELECT& select, const MatrixH& h, + VectorWR& wr, const VectorWI& wi, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(h) ) ); + return invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, + ifaill, ifailr, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorWR, typename VectorWI, typename MatrixVL, + typename MatrixVR, typename VectorIFAILL, typename VectorIFAILR > + static std::ptrdiff_t invoke( const Side side, const char eigsrc, + const char initv, VectorSELECT& select, const MatrixH& h, + VectorWR& wr, const VectorWI& wi, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, + ifaill, ifailr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return (n+2)*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hsein_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorW, typename MatrixVL, typename MatrixVR, + typename VectorIFAILL, typename VectorIFAILR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const Side side, const char eigsrc, + const char initv, const VectorSELECT& select, const MatrixH& h, + VectorW& w, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, detail::workspace2< + WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIFAILL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorIFAILR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAILR >::value) ); + BOOST_ASSERT( bindings::size(select) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size_column(h) >= 0 ); + BOOST_ASSERT( bindings::size_minor(h) == 1 || + bindings::stride_minor(h) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' ); + BOOST_ASSERT( initv == 'N' || initv == 'U' ); + return detail::hsein( side, eigsrc, initv, + bindings::begin_value(select), bindings::size_column(h), + bindings::begin_value(h), bindings::stride_major(h), + bindings::begin_value(w), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), mm, m, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(ifaill), bindings::begin_value(ifailr) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorW, typename MatrixVL, typename MatrixVR, + typename VectorIFAILL, typename VectorIFAILR > + static std::ptrdiff_t invoke( const Side side, const char eigsrc, + const char initv, const VectorSELECT& select, const MatrixH& h, + VectorW& w, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(h) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(h) ) ); + return invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m, + ifaill, ifailr, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorW, typename MatrixVL, typename MatrixVR, + typename VectorIFAILL, typename VectorIFAILR > + static std::ptrdiff_t invoke( const Side side, const char eigsrc, + const char initv, const VectorSELECT& select, const MatrixH& h, + VectorW& w, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m, + ifaill, ifailr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hsein_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hsein. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorWR, typename VectorWI, typename MatrixVL, + typename MatrixVR, typename VectorIFAILL, typename VectorIFAILR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hsein( const Side side, const char eigsrc, const char initv, + VectorSELECT& select, const MatrixH& h, VectorWR& wr, + const VectorWI& wi, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr, Workspace work ) { + return hsein_impl< typename bindings::value_type< + MatrixH >::type >::invoke( side, eigsrc, initv, select, h, wr, wi, + vl, vr, mm, m, ifaill, ifailr, work ); +} + +// +// Overloaded function for hsein. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorWR, typename VectorWI, typename MatrixVL, + typename MatrixVR, typename VectorIFAILL, typename VectorIFAILR > +inline typename boost::disable_if< detail::is_workspace< VectorIFAILR >, + std::ptrdiff_t >::type +hsein( const Side side, const char eigsrc, const char initv, + VectorSELECT& select, const MatrixH& h, VectorWR& wr, + const VectorWI& wi, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, + VectorIFAILL& ifaill, VectorIFAILR& ifailr ) { + return hsein_impl< typename bindings::value_type< + MatrixH >::type >::invoke( side, eigsrc, initv, select, h, wr, wi, + vl, vr, mm, m, ifaill, ifailr, optimal_workspace() ); +} + +// +// Overloaded function for hsein. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorW, typename MatrixVL, typename MatrixVR, + typename VectorIFAILL, typename VectorIFAILR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hsein( const Side side, const char eigsrc, const char initv, + const VectorSELECT& select, const MatrixH& h, VectorW& w, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr, + Workspace work ) { + return hsein_impl< typename bindings::value_type< + MatrixH >::type >::invoke( side, eigsrc, initv, select, h, w, vl, + vr, mm, m, ifaill, ifailr, work ); +} + +// +// Overloaded function for hsein. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixH, + typename VectorW, typename MatrixVL, typename MatrixVR, + typename VectorIFAILL, typename VectorIFAILR > +inline typename boost::disable_if< detail::is_workspace< VectorIFAILR >, + std::ptrdiff_t >::type +hsein( const Side side, const char eigsrc, const char initv, + const VectorSELECT& select, const MatrixH& h, VectorW& w, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr ) { + return hsein_impl< typename bindings::value_type< + MatrixH >::type >::invoke( side, eigsrc, initv, select, h, w, vl, + vr, mm, m, ifaill, ifailr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/hseqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/hseqr.hpp new file mode 100644 index 0000000..a72fff4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/hseqr.hpp @@ -0,0 +1,463 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hseqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t hseqr( const char job, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, float* h, const fortran_int_t ldh, float* wr, + float* wi, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t hseqr( const char job, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, double* h, const fortran_int_t ldh, + double* wr, double* wi, double* z, const fortran_int_t ldz, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, wr, wi, z, &ldz, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t hseqr( const char job, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* h, + const fortran_int_t ldh, std::complex* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, w, z, &ldz, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t hseqr( const char job, const char compz, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* h, + const fortran_int_t ldh, std::complex* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZHSEQR( &job, &compz, &n, &ilo, &ihi, h, &ldh, w, z, &ldz, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hseqr. +// +template< typename Value, typename Enable = void > +struct hseqr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hseqr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixH, typename VectorWR, typename VectorWI, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const char job, const char compz, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixH& h, VectorWR& wr, VectorWI& wi, MatrixZ& z, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(h) ); + BOOST_ASSERT( bindings::size_column(h) >= 0 ); + BOOST_ASSERT( bindings::size_minor(h) == 1 || + bindings::stride_minor(h) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + BOOST_ASSERT( job == 'E' || job == 'S' ); + return detail::hseqr( job, compz, bindings::size_column(h), ilo, ihi, + bindings::begin_value(h), bindings::stride_major(h), + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixH, typename VectorWR, typename VectorWI, + typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compz, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixH& h, VectorWR& wr, VectorWI& wi, MatrixZ& z, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(h) ) ); + return invoke( job, compz, ilo, ihi, h, wr, wi, z, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixH, typename VectorWR, typename VectorWI, + typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compz, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixH& h, VectorWR& wr, VectorWI& wi, MatrixZ& z, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::hseqr( job, compz, bindings::size_column(h), ilo, ihi, + bindings::begin_value(h), bindings::stride_major(h), + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( job, compz, ilo, ihi, h, wr, wi, z, + workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hseqr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixH, typename VectorW, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char job, const char compz, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixH& h, VectorW& w, MatrixZ& z, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixH >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixH >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(h) )); + BOOST_ASSERT( bindings::size_column(h) >= 0 ); + BOOST_ASSERT( bindings::size_minor(h) == 1 || + bindings::stride_minor(h) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(h) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(h)) ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + BOOST_ASSERT( job == 'E' || job == 'S' ); + return detail::hseqr( job, compz, bindings::size_column(h), ilo, ihi, + bindings::begin_value(h), bindings::stride_major(h), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixH, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compz, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixH& h, VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(h) ) ); + return invoke( job, compz, ilo, ihi, h, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixH, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char job, const char compz, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixH& h, VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::hseqr( job, compz, bindings::size_column(h), ilo, ihi, + bindings::begin_value(h), bindings::stride_major(h), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( job, compz, ilo, ihi, h, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hseqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hseqr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixH, typename VectorWR, typename VectorWI, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hseqr( const char job, const char compz, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixH& h, VectorWR& wr, VectorWI& wi, + MatrixZ& z, Workspace work ) { + return hseqr_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compz, ilo, ihi, h, wr, wi, z, + work ); +} + +// +// Overloaded function for hseqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixH, typename VectorWR, typename VectorWI, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hseqr( const char job, const char compz, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixH& h, VectorWR& wr, VectorWI& wi, + MatrixZ& z ) { + return hseqr_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compz, ilo, ihi, h, wr, wi, z, + optimal_workspace() ); +} + +// +// Overloaded function for hseqr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixH, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< mpl::and_< is_complex< + typename bindings::value_type< MatrixH >::type >, + detail::is_workspace< Workspace > >, + std::ptrdiff_t >::type +hseqr( const char job, const char compz, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixH& h, VectorW& w, MatrixZ& z, + Workspace work ) { + return hseqr_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compz, ilo, ihi, h, w, z, work ); +} + +// +// Overloaded function for hseqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixH, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< mpl::or_< is_real< + typename bindings::value_type< MatrixH >::type >, + detail::is_workspace< MatrixZ > >, + std::ptrdiff_t >::type +hseqr( const char job, const char compz, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixH& h, VectorW& w, MatrixZ& z ) { + return hseqr_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compz, ilo, ihi, h, w, z, + optimal_workspace() ); +} + +// +// Overloaded function for hseqr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixH, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< mpl::and_< is_real< + typename bindings::value_type< MatrixH >::type >, + detail::is_workspace< Workspace > >, + std::ptrdiff_t >::type +hseqr( const char job, const char compz, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixH& h, VectorW& w, MatrixZ& z, + Workspace work ) { + std::ptrdiff_t info = hseqr_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compz, ilo, ihi, h, + bindings::detail::real_part_view(w), bindings::detail::imag_part_view(w), + z, work ); + bindings::detail::interlace(w); + return info; +} + +// +// Overloaded function for hseqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixH, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< mpl::or_< is_complex< + typename bindings::value_type< MatrixH >::type >, + detail::is_workspace< MatrixZ > >, + std::ptrdiff_t >::type +hseqr( const char job, const char compz, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixH& h, VectorW& w, MatrixZ& z ) { + std::ptrdiff_t info = hseqr_impl< typename bindings::value_type< + MatrixH >::type >::invoke( job, compz, ilo, ihi, h, + bindings::detail::real_part_view(w), bindings::detail::imag_part_view(w), + z, optimal_workspace() ); + bindings::detail::interlace(w); + return info; +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/opgtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/opgtr.hpp new file mode 100644 index 0000000..78da320 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/opgtr.hpp @@ -0,0 +1,206 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_OPGTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_OPGTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for opgtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t opgtr( const char uplo, const fortran_int_t n, + const float* ap, const float* tau, float* q, const fortran_int_t ldq, + float* work ) { + fortran_int_t info(0); + LAPACK_SOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t opgtr( const char uplo, const fortran_int_t n, + const double* ap, const double* tau, double* q, + const fortran_int_t ldq, double* work ) { + fortran_int_t info(0); + LAPACK_DOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to opgtr. +// +template< typename Value > +struct opgtr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ, + typename WORK > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(ap) >= + bindings::size_column(q)*(bindings::size_column(q)+1)/2 ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(q)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(q) )); + BOOST_ASSERT( bindings::size_column(q) >= 0 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(q)) ); + return detail::opgtr( uplo, bindings::size_column(q), + bindings::begin_value(ap), bindings::begin_value(tau), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(q) ) ); + return invoke( uplo, ap, tau, q, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, ap, tau, q, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n-1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the opgtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for opgtr. Its overload differs for +// * User-defined workspace +// +template< typename VectorAP, typename VectorTAU, typename MatrixQ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +opgtr( const char uplo, const VectorAP& ap, const VectorTAU& tau, + MatrixQ& q, Workspace work ) { + return opgtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( uplo, ap, tau, q, work ); +} + +// +// Overloaded function for opgtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorAP, typename VectorTAU, typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +opgtr( const char uplo, const VectorAP& ap, const VectorTAU& tau, + MatrixQ& q ) { + return opgtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( uplo, ap, tau, q, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/opmtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/opmtr.hpp new file mode 100644 index 0000000..1135c6c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/opmtr.hpp @@ -0,0 +1,225 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_OPMTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_OPMTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for opmtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t opmtr( const Side, const char uplo, const Trans, + const fortran_int_t m, const fortran_int_t n, const float* ap, + const float* tau, float* c, const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SOPMTR( &lapack_option< Side >::value, &uplo, &lapack_option< + Trans >::value, &m, &n, ap, tau, c, &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t opmtr( const Side, const char uplo, const Trans, + const fortran_int_t m, const fortran_int_t n, const double* ap, + const double* tau, double* c, const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DOPMTR( &lapack_option< Side >::value, &uplo, &lapack_option< + Trans >::value, &m, &n, ap, tau, c, &ldc, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to opmtr. +// +template< typename Value > +struct opmtr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::opmtr( side, uplo, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(ap), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + return invoke( side, uplo, ap, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the opmtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for opmtr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +opmtr( const Side side, const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return opmtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( side, uplo, ap, tau, c, work ); +} + +// +// Overloaded function for opmtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +opmtr( const Side side, const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixC& c ) { + return opmtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( side, uplo, ap, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orgbr.hpp b/sdk/boost/numeric/bindings/lapack/computational/orgbr.hpp new file mode 100644 index 0000000..6d92f03 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orgbr.hpp @@ -0,0 +1,212 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGBR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGBR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orgbr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t orgbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, float* a, + const fortran_int_t lda, const float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t orgbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, double* a, + const fortran_int_t lda, const double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orgbr. +// +template< typename Value > +struct orgbr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( m, n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + m) ); + BOOST_ASSERT( k >= 0 ); + BOOST_ASSERT( m >= 0 ); + BOOST_ASSERT( vect == 'Q' || vect == 'P' ); + return detail::orgbr( vect, m, n, k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( m, n ) ); + return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::orgbr( vect, m, n, k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, std::min< std::ptrdiff_t >( m, + n ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orgbr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orgbr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orgbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, Workspace work ) { + return orgbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, m, n, k, a, tau, work ); +} + +// +// Overloaded function for orgbr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orgbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau ) { + return orgbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, m, n, k, a, tau, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orghr.hpp b/sdk/boost/numeric/bindings/lapack/computational/orghr.hpp new file mode 100644 index 0000000..ec76dc8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orghr.hpp @@ -0,0 +1,209 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGHR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGHR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orghr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t orghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t orghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orghr. +// +template< typename Value > +struct orghr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( ihi, ilo )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::orghr( n, ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( ihi, + ilo ) ); + return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::orghr( n, ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ihi, + const std::ptrdiff_t ilo ) { + return ihi-ilo; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orghr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orghr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, const VectorTAU& tau, + Workspace work ) { + return orghr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, ilo, ihi, a, tau, work ); +} + +// +// Overloaded function for orghr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, const VectorTAU& tau ) { + return orghr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, ilo, ihi, a, tau, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orglq.hpp b/sdk/boost/numeric/bindings/lapack/computational/orglq.hpp new file mode 100644 index 0000000..f97290a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orglq.hpp @@ -0,0 +1,203 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGLQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGLQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orglq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t orglq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t orglq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orglq. +// +template< typename Value > +struct orglq_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::orglq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::orglq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >( 1, m ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orglq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orglq. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orglq( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return orglq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for orglq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orglq( MatrixA& a, const VectorTAU& tau ) { + return orglq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orgql.hpp b/sdk/boost/numeric/bindings/lapack/computational/orgql.hpp new file mode 100644 index 0000000..859b0d7 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orgql.hpp @@ -0,0 +1,202 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGQL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGQL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orgql is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t orgql( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t orgql( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orgql. +// +template< typename Value > +struct orgql_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::orgql( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::orgql( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orgql_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orgql. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orgql( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return orgql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for orgql. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orgql( MatrixA& a, const VectorTAU& tau ) { + return orgql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orgqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/orgqr.hpp new file mode 100644 index 0000000..2149f25 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orgqr.hpp @@ -0,0 +1,202 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orgqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t orgqr( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t orgqr( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orgqr. +// +template< typename Value > +struct orgqr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::orgqr( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::orgqr( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orgqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orgqr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orgqr( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return orgqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for orgqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orgqr( MatrixA& a, const VectorTAU& tau ) { + return orgqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orgrq.hpp b/sdk/boost/numeric/bindings/lapack/computational/orgrq.hpp new file mode 100644 index 0000000..a7903e5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orgrq.hpp @@ -0,0 +1,203 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGRQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGRQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orgrq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t orgrq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t orgrq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orgrq. +// +template< typename Value > +struct orgrq_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::orgrq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::orgrq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >( 1, m ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orgrq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orgrq. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orgrq( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return orgrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for orgrq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orgrq( MatrixA& a, const VectorTAU& tau ) { + return orgrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/orgtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/orgtr.hpp new file mode 100644 index 0000000..2de5d34 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/orgtr.hpp @@ -0,0 +1,208 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORGTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for orgtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t orgtr( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, const float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGTR( &lapack_option< UpLo >::value, &n, a, &lda, tau, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t orgtr( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, const double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGTR( &lapack_option< UpLo >::value, &n, a, &lda, tau, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to orgtr. +// +template< typename Value > +struct orgtr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::orgtr( uplo(), n, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + return invoke( n, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::orgtr( uplo(), n, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( n, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n-1); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the orgtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for orgtr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +orgtr( const fortran_int_t n, MatrixA& a, const VectorTAU& tau, + Workspace work ) { + return orgtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, a, tau, work ); +} + +// +// Overloaded function for orgtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +orgtr( const fortran_int_t n, MatrixA& a, const VectorTAU& tau ) { + return orgtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormbr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormbr.hpp new file mode 100644 index 0000000..a772c51 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormbr.hpp @@ -0,0 +1,244 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMBR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMBR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormbr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormbr( const char vect, const Side, const Trans, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const float* a, const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMBR( &vect, &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormbr( const char vect, const Side, const Trans, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const double* a, const fortran_int_t lda, const double* tau, + double* c, const fortran_int_t ldc, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMBR( &vect, &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormbr. +// +template< typename Value > +struct ormbr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const char vect, const Side side, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + BOOST_ASSERT( vect == 'Q' || vect == 'P' ); + return detail::ormbr( vect, side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const char vect, const Side side, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( vect, side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const char vect, const Side side, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormbr( vect, side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( vect, side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormbr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormbr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormbr( const char vect, const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return ormbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, side, a, tau, c, work ); +} + +// +// Overloaded function for ormbr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormbr( const char vect, const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c ) { + return ormbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, side, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormhr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormhr.hpp new file mode 100644 index 0000000..87c1404 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormhr.hpp @@ -0,0 +1,245 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMHR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMHR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormhr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormhr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, const float* a, const fortran_int_t lda, + const float* tau, float* c, const fortran_int_t ldc, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMHR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormhr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, const double* a, const fortran_int_t lda, + const double* tau, double* c, const fortran_int_t ldc, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMHR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormhr. +// +template< typename Value > +struct ormhr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormhr( side, trans(), bindings::size_row(c), + bindings::size_column(c), ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormhr( side, trans(), bindings::size_row(c), + bindings::size_column(c), ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormhr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormhr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormhr( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return ormhr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, ilo, ihi, a, tau, c, work ); +} + +// +// Overloaded function for ormhr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormhr( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return ormhr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, ilo, ihi, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormlq.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormlq.hpp new file mode 100644 index 0000000..f58b150 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormlq.hpp @@ -0,0 +1,241 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMLQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMLQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormlq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormlq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMLQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormlq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMLQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormlq. +// +template< typename Value > +struct ormlq_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size(tau)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormlq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormlq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormlq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormlq. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormlq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return ormlq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for ormlq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormlq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return ormlq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormql.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormql.hpp new file mode 100644 index 0000000..4e67c53 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormql.hpp @@ -0,0 +1,239 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMQL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMQL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormql is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormql( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMQL( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormql( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMQL( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormql. +// +template< typename Value > +struct ormql_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormql( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormql( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormql_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormql. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormql( const Side side, MatrixA& a, const VectorTAU& tau, MatrixC& c, + Workspace work ) { + return ormql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for ormql. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormql( const Side side, MatrixA& a, const VectorTAU& tau, MatrixC& c ) { + return ormql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormqr.hpp new file mode 100644 index 0000000..be4a356 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormqr.hpp @@ -0,0 +1,239 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormqr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMQR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormqr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMQR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormqr. +// +template< typename Value > +struct ormqr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormqr( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormqr( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormqr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormqr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return ormqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for ormqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormqr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return ormqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormrq.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormrq.hpp new file mode 100644 index 0000000..5518b81 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormrq.hpp @@ -0,0 +1,241 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMRQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMRQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormrq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormrq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMRQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormrq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMRQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormrq. +// +template< typename Value > +struct ormrq_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size(tau)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormrq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormrq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormrq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormrq. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormrq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return ormrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for ormrq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormrq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return ormrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormrz.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormrz.hpp new file mode 100644 index 0000000..ba6e543 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormrz.hpp @@ -0,0 +1,244 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMRZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMRZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormrz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormrz( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const fortran_int_t l, + const float* a, const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMRZ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t ormrz( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const fortran_int_t l, + const double* a, const fortran_int_t lda, const double* tau, + double* c, const fortran_int_t ldc, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMRZ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormrz. +// +template< typename Value > +struct ormrz_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size(tau)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormrz( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::ormrz( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormrz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormrz. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormrz( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return ormrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for ormrz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormrz( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return ormrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ormtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ormtr.hpp new file mode 100644 index 0000000..6375c9b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ormtr.hpp @@ -0,0 +1,241 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_ORMTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ormtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename UpLo, typename Trans > +inline std::ptrdiff_t ormtr( const Side, const UpLo, const Trans, + const fortran_int_t m, const fortran_int_t n, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMTR( &lapack_option< Side >::value, &lapack_option< + UpLo >::value, &lapack_option< Trans >::value, &m, &n, a, &lda, + tau, c, &ldc, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename UpLo, typename Trans > +inline std::ptrdiff_t ormtr( const Side, const UpLo, const Trans, + const fortran_int_t m, const fortran_int_t n, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMTR( &lapack_option< Side >::value, &lapack_option< + UpLo >::value, &lapack_option< Trans >::value, &m, &n, a, &lda, + tau, c, &ldc, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ormtr. +// +template< typename Value > +struct ormtr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::ormtr( side, uplo(), trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + real_type opt_size_work; + detail::ormtr( side, uplo(), trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ormtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ormtr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ormtr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return ormtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for ormtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +ormtr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return ormtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pbcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/pbcon.hpp new file mode 100644 index 0000000..4be498b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pbcon.hpp @@ -0,0 +1,347 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbcon( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const float* ab, const fortran_int_t ldab, + const float anorm, float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPBCON( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbcon( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const double* ab, const fortran_int_t ldab, + const double anorm, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPBCON( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbcon( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const std::complex* ab, + const fortran_int_t ldab, const float anorm, float& rcond, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPBCON( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &anorm, + &rcond, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbcon( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const std::complex* ab, + const fortran_int_t ldab, const double anorm, double& rcond, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPBCON( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &anorm, + &rcond, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbcon. +// +template< typename Value, typename Enable = void > +struct pbcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pbcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAB& ab, const real_type anorm, + real_type& rcond, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + return detail::pbcon( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), anorm, rcond, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const MatrixAB& ab, const real_type anorm, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( ab, anorm, rcond, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const MatrixAB& ab, const real_type anorm, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( ab, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pbcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAB& ab, const real_type anorm, + real_type& rcond, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth_upper(ab) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_upper(ab)+1 ); + return detail::pbcon( uplo(), bindings::size_column(ab), + bindings::bandwidth_upper(ab), bindings::begin_value(ab), + bindings::stride_major(ab), anorm, rcond, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const MatrixAB& ab, const real_type anorm, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( ab, anorm, rcond, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const MatrixAB& ab, const real_type anorm, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( ab, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pbcon( const MatrixAB& ab, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type anorm, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rcond, Workspace work ) { + return pbcon_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, anorm, rcond, work ); +} + +// +// Overloaded function for pbcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB > +inline typename boost::disable_if< detail::is_workspace< MatrixAB >, + std::ptrdiff_t >::type +pbcon( const MatrixAB& ab, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type anorm, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rcond ) { + return pbcon_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pbequ.hpp b/sdk/boost/numeric/bindings/lapack/computational/pbequ.hpp new file mode 100644 index 0000000..41ea7d3 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pbequ.hpp @@ -0,0 +1,221 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBEQU_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBEQU_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbequ is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbequ( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const float* ab, const fortran_int_t ldab, + float* s, float& scond, float& amax ) { + fortran_int_t info(0); + LAPACK_SPBEQU( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, s, + &scond, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbequ( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const double* ab, const fortran_int_t ldab, + double* s, double& scond, double& amax ) { + fortran_int_t info(0); + LAPACK_DPBEQU( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, s, + &scond, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbequ( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const std::complex* ab, + const fortran_int_t ldab, float* s, float& scond, float& amax ) { + fortran_int_t info(0); + LAPACK_CPBEQU( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, s, + &scond, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbequ( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const std::complex* ab, + const fortran_int_t ldab, double* s, double& scond, double& amax ) { + fortran_int_t info(0); + LAPACK_ZPBEQU( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, s, + &scond, &amax, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbequ. +// +template< typename Value, typename Enable = void > +struct pbequ_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pbequ_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorS > + static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s, + real_type& scond, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + return detail::pbequ( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(s), scond, + amax ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pbequ_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorS > + static std::ptrdiff_t invoke( const MatrixAB& ab, VectorS& s, + real_type& scond, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + return detail::pbequ( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(s), scond, + amax ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbequ_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbequ. Its overload differs for +// +template< typename MatrixAB, typename VectorS > +inline std::ptrdiff_t pbequ( const MatrixAB& ab, VectorS& s, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& scond, typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type& amax ) { + return pbequ_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, s, scond, amax ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pbrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/pbrfs.hpp new file mode 100644 index 0000000..18e470b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pbrfs.hpp @@ -0,0 +1,457 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbrfs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, const float* ab, + const fortran_int_t ldab, const float* afb, const fortran_int_t ldafb, + const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPBRFS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + afb, &ldafb, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbrfs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, const double* ab, + const fortran_int_t ldab, const double* afb, + const fortran_int_t ldafb, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPBRFS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + afb, &ldafb, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbrfs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, + const std::complex* ab, const fortran_int_t ldab, + const std::complex* afb, const fortran_int_t ldafb, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPBRFS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + afb, &ldafb, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbrfs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, + const std::complex* ab, const fortran_int_t ldab, + const std::complex* afb, const fortran_int_t ldafb, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPBRFS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + afb, &ldafb, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbrfs. +// +template< typename Value, typename Enable = void > +struct pbrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pbrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + return detail::pbrfs( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(afb), bindings::stride_major(afb), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( ab, afb, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pbrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + return detail::pbrfs( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(afb), bindings::stride_major(afb), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( ab, afb, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAB& ab, const MatrixAFB& afb, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( ab, afb, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbrfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pbrfs( const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return pbrfs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, afb, b, x, ferr, berr, work ); +} + +// +// Overloaded function for pbrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixAFB, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +pbrfs( const MatrixAB& ab, const MatrixAFB& afb, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return pbrfs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, afb, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pbstf.hpp b/sdk/boost/numeric/bindings/lapack/computational/pbstf.hpp new file mode 100644 index 0000000..68cf8e1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pbstf.hpp @@ -0,0 +1,162 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBSTF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBSTF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbstf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbstf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, float* ab, const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_SPBSTF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbstf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, double* ab, const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_DPBSTF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbstf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, std::complex* ab, + const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_CPBSTF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbstf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, std::complex* ab, + const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_ZPBSTF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbstf. +// +template< typename Value > +struct pbstf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( MatrixAB& ab ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + return detail::pbstf( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbstf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbstf. Its overload differs for +// +template< typename MatrixAB > +inline std::ptrdiff_t pbstf( MatrixAB& ab ) { + return pbstf_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pbtrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/pbtrf.hpp new file mode 100644 index 0000000..8c97e72 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pbtrf.hpp @@ -0,0 +1,162 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbtrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, float* ab, const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_SPBTRF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, double* ab, const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_DPBTRF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, std::complex* ab, + const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_CPBTRF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrf( const UpLo, const fortran_int_t n, + const fortran_int_t kd, std::complex* ab, + const fortran_int_t ldab ) { + fortran_int_t info(0); + LAPACK_ZPBTRF( &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbtrf. +// +template< typename Value > +struct pbtrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( MatrixAB& ab ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + return detail::pbtrf( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbtrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbtrf. Its overload differs for +// +template< typename MatrixAB > +inline std::ptrdiff_t pbtrf( MatrixAB& ab ) { + return pbtrf_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pbtrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/pbtrs.hpp new file mode 100644 index 0000000..a8e5bc4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pbtrs.hpp @@ -0,0 +1,181 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PBTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbtrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, const float* ab, + const fortran_int_t ldab, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPBTRS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, const double* ab, + const fortran_int_t ldab, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPBTRS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, + const std::complex* ab, const fortran_int_t ldab, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPBTRS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbtrs( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, + const std::complex* ab, const fortran_int_t ldab, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPBTRS( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, + b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbtrs. +// +template< typename Value > +struct pbtrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixAB& ab, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + return detail::pbtrs( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbtrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbtrs. Its overload differs for +// +template< typename MatrixAB, typename MatrixB > +inline std::ptrdiff_t pbtrs( const MatrixAB& ab, MatrixB& b ) { + return pbtrs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pftrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/pftrf.hpp new file mode 100644 index 0000000..0499eec --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pftrf.hpp @@ -0,0 +1,154 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PFTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PFTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pftrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename TransR > +inline std::ptrdiff_t pftrf( const TransR, const char uplo, + const fortran_int_t n, float* a ) { + fortran_int_t info(0); + LAPACK_SPFTRF( &lapack_option< TransR >::value, &uplo, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename TransR > +inline std::ptrdiff_t pftrf( const TransR, const char uplo, + const fortran_int_t n, double* a ) { + fortran_int_t info(0); + LAPACK_DPFTRF( &lapack_option< TransR >::value, &uplo, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR > +inline std::ptrdiff_t pftrf( const TransR, const char uplo, + const fortran_int_t n, std::complex* a ) { + fortran_int_t info(0); + LAPACK_CPFTRF( &lapack_option< TransR >::value, &uplo, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR > +inline std::ptrdiff_t pftrf( const TransR, const char uplo, + const fortran_int_t n, std::complex* a ) { + fortran_int_t info(0); + LAPACK_ZPFTRF( &lapack_option< TransR >::value, &uplo, &n, a, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pftrf. +// +template< typename Value > +struct pftrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char uplo, MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename blas::detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type transr; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column_op(a, transr()) >= 0 ); + return detail::pftrf( transr(), uplo, bindings::size_column_op(a, + transr()), bindings::begin_value(a) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pftrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pftrf. Its overload differs for +// +template< typename MatrixA > +inline std::ptrdiff_t pftrf( const char uplo, MatrixA& a ) { + return pftrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( uplo, a ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pftri.hpp b/sdk/boost/numeric/bindings/lapack/computational/pftri.hpp new file mode 100644 index 0000000..8a515d6 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pftri.hpp @@ -0,0 +1,159 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PFTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PFTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pftri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftri( const TransR, const UpLo, const fortran_int_t n, + float* a ) { + fortran_int_t info(0); + LAPACK_SPFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftri( const TransR, const UpLo, const fortran_int_t n, + double* a ) { + fortran_int_t info(0); + LAPACK_DPFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftri( const TransR, const UpLo, const fortran_int_t n, + std::complex* a ) { + fortran_int_t info(0); + LAPACK_CPFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftri( const TransR, const UpLo, const fortran_int_t n, + std::complex* a ) { + fortran_int_t info(0); + LAPACK_ZPFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, a, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pftri. +// +template< typename Value > +struct pftri_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA > + static std::ptrdiff_t invoke( MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename blas::detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type transr; + typedef typename result_of::uplo_tag< MatrixA, transr >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column_op(a, transr()) >= 0 ); + return detail::pftri( transr(), uplo(), bindings::size_column_op(a, + transr()), bindings::begin_value(a) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pftri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pftri. Its overload differs for +// +template< typename MatrixA > +inline std::ptrdiff_t pftri( MatrixA& a ) { + return pftri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pftrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/pftrs.hpp new file mode 100644 index 0000000..97de34d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pftrs.hpp @@ -0,0 +1,173 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PFTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PFTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pftrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftrs( const TransR, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, float* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPFTRS( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, &nrhs, a, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftrs( const TransR, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPFTRS( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, &nrhs, a, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftrs( const TransR, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPFTRS( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, &nrhs, a, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR, typename UpLo > +inline std::ptrdiff_t pftrs( const TransR, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPFTRS( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &n, &nrhs, a, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pftrs. +// +template< typename Value > +struct pftrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixA& a, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type transr; + typedef typename result_of::uplo_tag< MatrixA, transr >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, transr()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, transr())) ); + return detail::pftrs( transr(), uplo(), bindings::size_column_op(a, + transr()), bindings::size_column(b), bindings::begin_value(a), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pftrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pftrs. Its overload differs for +// +template< typename MatrixA, typename MatrixB > +inline std::ptrdiff_t pftrs( const MatrixA& a, MatrixB& b ) { + return pftrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pocon.hpp b/sdk/boost/numeric/bindings/lapack/computational/pocon.hpp new file mode 100644 index 0000000..fbadc15 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pocon.hpp @@ -0,0 +1,340 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pocon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pocon( const UpLo, const fortran_int_t n, const float* a, + const fortran_int_t lda, const float anorm, float& rcond, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPOCON( &lapack_option< UpLo >::value, &n, a, &lda, &anorm, &rcond, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pocon( const UpLo, const fortran_int_t n, + const double* a, const fortran_int_t lda, const double anorm, + double& rcond, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPOCON( &lapack_option< UpLo >::value, &n, a, &lda, &anorm, &rcond, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pocon( const UpLo, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const float anorm, float& rcond, std::complex* work, + float* rwork ) { + fortran_int_t info(0); + LAPACK_CPOCON( &lapack_option< UpLo >::value, &n, a, &lda, &anorm, &rcond, + work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pocon( const UpLo, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const double anorm, double& rcond, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPOCON( &lapack_option< UpLo >::value, &n, a, &lda, &anorm, &rcond, + work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pocon. +// +template< typename Value, typename Enable = void > +struct pocon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pocon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm, + real_type& rcond, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::pocon( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), anorm, + rcond, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( a, anorm, rcond, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pocon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm, + real_type& rcond, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::pocon( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), anorm, + rcond, bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, anorm, rcond, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const MatrixA& a, const real_type anorm, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pocon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pocon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pocon( const MatrixA& a, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type anorm, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcond, Workspace work ) { + return pocon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, anorm, rcond, work ); +} + +// +// Overloaded function for pocon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +pocon( const MatrixA& a, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type anorm, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcond ) { + return pocon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, anorm, rcond, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/poequ.hpp b/sdk/boost/numeric/bindings/lapack/computational/poequ.hpp new file mode 100644 index 0000000..596358d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/poequ.hpp @@ -0,0 +1,203 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POEQU_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POEQU_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for poequ is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t poequ( const fortran_int_t n, const float* a, + const fortran_int_t lda, float* s, float& scond, float& amax ) { + fortran_int_t info(0); + LAPACK_SPOEQU( &n, a, &lda, s, &scond, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t poequ( const fortran_int_t n, const double* a, + const fortran_int_t lda, double* s, double& scond, double& amax ) { + fortran_int_t info(0); + LAPACK_DPOEQU( &n, a, &lda, s, &scond, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t poequ( const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, float* s, + float& scond, float& amax ) { + fortran_int_t info(0); + LAPACK_CPOEQU( &n, a, &lda, s, &scond, &amax, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t poequ( const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, double* s, + double& scond, double& amax ) { + fortran_int_t info(0); + LAPACK_ZPOEQU( &n, a, &lda, s, &scond, &amax, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to poequ. +// +template< typename Value, typename Enable = void > +struct poequ_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct poequ_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorS > + static std::ptrdiff_t invoke( const MatrixA& a, VectorS& s, + real_type& scond, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::poequ( bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(s), scond, amax ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct poequ_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorS > + static std::ptrdiff_t invoke( const MatrixA& a, VectorS& s, + real_type& scond, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::poequ( bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(s), scond, amax ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the poequ_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for poequ. Its overload differs for +// +template< typename MatrixA, typename VectorS > +inline std::ptrdiff_t poequ( const MatrixA& a, VectorS& s, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& scond, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& amax ) { + return poequ_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, s, scond, amax ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/porfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/porfs.hpp new file mode 100644 index 0000000..a6af1ad --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/porfs.hpp @@ -0,0 +1,452 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PORFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PORFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for porfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t porfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const float* af, const fortran_int_t ldaf, const float* b, + const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float* ferr, float* berr, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPORFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t porfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const double* af, const fortran_int_t ldaf, const double* b, + const fortran_int_t ldb, double* x, const fortran_int_t ldx, + double* ferr, double* berr, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPORFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t porfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPORFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t porfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPORFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to porfs. +// +template< typename Value, typename Enable = void > +struct porfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct porfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::porfs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( a, af, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, af, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct porfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::porfs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, af, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, af, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the porfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for porfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +porfs( const MatrixA& a, const MatrixAF& af, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return porfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, b, x, ferr, berr, work ); +} + +// +// Overloaded function for porfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +porfs( const MatrixA& a, const MatrixAF& af, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return porfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/potrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/potrf.hpp new file mode 100644 index 0000000..f64a511 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/potrf.hpp @@ -0,0 +1,220 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for potrf is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const int n, float* a, + const int lda ) { + return clapack_spotrf( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const int n, double* a, + const int lda ) { + return clapack_dpotrf( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const int n, + std::complex* a, const int lda ) { + return clapack_cpotrf( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const int n, + std::complex* a, const int lda ) { + return clapack_zpotrf( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const fortran_int_t n, + float* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SPOTRF( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const fortran_int_t n, + double* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DPOTRF( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CPOTRF( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrf( Order, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZPOTRF( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to potrf. +// +template< typename Value > +struct potrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA > + static std::ptrdiff_t invoke( MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::potrf( order(), uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the potrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for potrf. Its overload differs for +// +template< typename MatrixA > +inline std::ptrdiff_t potrf( MatrixA& a ) { + return potrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/potri.hpp b/sdk/boost/numeric/bindings/lapack/computational/potri.hpp new file mode 100644 index 0000000..6abfdcb --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/potri.hpp @@ -0,0 +1,220 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for potri is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const int n, float* a, + const int lda ) { + return clapack_spotri( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const int n, double* a, + const int lda ) { + return clapack_dpotri( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const int n, + std::complex* a, const int lda ) { + return clapack_cpotri( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const int n, + std::complex* a, const int lda ) { + return clapack_zpotri( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const fortran_int_t n, + float* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SPOTRI( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const fortran_int_t n, + double* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DPOTRI( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CPOTRI( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potri( Order, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZPOTRI( &lapack_option< UpLo >::value, &n, a, &lda, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to potri. +// +template< typename Value > +struct potri_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA > + static std::ptrdiff_t invoke( MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::potri( order(), uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the potri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for potri. Its overload differs for +// +template< typename MatrixA > +inline std::ptrdiff_t potri( MatrixA& a ) { + return potri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/potrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/potrs.hpp new file mode 100644 index 0000000..2587e5d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/potrs.hpp @@ -0,0 +1,245 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_POTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for potrs is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const int n, const int nrhs, + const float* a, const int lda, float* b, const int ldb ) { + return clapack_spotrs( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const int n, const int nrhs, + const double* a, const int lda, double* b, const int ldb ) { + return clapack_dpotrs( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const int n, const int nrhs, + const std::complex* a, const int lda, std::complex* b, + const int ldb ) { + return clapack_cpotrs( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const int n, const int nrhs, + const std::complex* a, const int lda, std::complex* b, + const int ldb ) { + return clapack_zpotrs( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + float* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SPOTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DPOTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CPOTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t potrs( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZPOTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to potrs. +// +template< typename Value > +struct potrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixA& a, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::potrs( order(), uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the potrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for potrs. Its overload differs for +// +template< typename MatrixA, typename MatrixB > +inline std::ptrdiff_t potrs( const MatrixA& a, MatrixB& b ) { + return potrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ppcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/ppcon.hpp new file mode 100644 index 0000000..30ec573 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ppcon.hpp @@ -0,0 +1,328 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ppcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppcon( const UpLo, const fortran_int_t n, + const float* ap, const float anorm, float& rcond, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppcon( const UpLo, const fortran_int_t n, + const double* ap, const double anorm, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppcon( const UpLo, const fortran_int_t n, + const std::complex* ap, const float anorm, float& rcond, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond, + work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppcon( const UpLo, const fortran_int_t n, + const std::complex* ap, const double anorm, double& rcond, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPPCON( &lapack_option< UpLo >::value, &n, ap, &anorm, &rcond, + work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ppcon. +// +template< typename Value, typename Enable = void > +struct ppcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ppcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm, + real_type& rcond, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::ppcon( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), anorm, rcond, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( ap, anorm, rcond, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ppcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm, + real_type& rcond, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::ppcon( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), anorm, rcond, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( ap, anorm, rcond, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const MatrixAP& ap, const real_type anorm, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ppcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ppcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ppcon( const MatrixAP& ap, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type anorm, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& rcond, Workspace work ) { + return ppcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, anorm, rcond, work ); +} + +// +// Overloaded function for ppcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP > +inline typename boost::disable_if< detail::is_workspace< MatrixAP >, + std::ptrdiff_t >::type +ppcon( const MatrixAP& ap, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type anorm, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& rcond ) { + return ppcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ppequ.hpp b/sdk/boost/numeric/bindings/lapack/computational/ppequ.hpp new file mode 100644 index 0000000..277e904 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ppequ.hpp @@ -0,0 +1,202 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPEQU_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPEQU_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ppequ is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppequ( const UpLo, const fortran_int_t n, + const float* ap, float* s, float& scond, float& amax ) { + fortran_int_t info(0); + LAPACK_SPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppequ( const UpLo, const fortran_int_t n, + const double* ap, double* s, double& scond, double& amax ) { + fortran_int_t info(0); + LAPACK_DPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppequ( const UpLo, const fortran_int_t n, + const std::complex* ap, float* s, float& scond, float& amax ) { + fortran_int_t info(0); + LAPACK_CPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppequ( const UpLo, const fortran_int_t n, + const std::complex* ap, double* s, double& scond, + double& amax ) { + fortran_int_t info(0); + LAPACK_ZPPEQU( &lapack_option< UpLo >::value, &n, ap, s, &scond, &amax, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ppequ. +// +template< typename Value, typename Enable = void > +struct ppequ_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ppequ_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorS > + static std::ptrdiff_t invoke( const MatrixAP& ap, VectorS& s, + real_type& scond, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::ppequ( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(s), scond, + amax ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ppequ_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorS > + static std::ptrdiff_t invoke( const MatrixAP& ap, VectorS& s, + real_type& scond, real_type& amax ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::ppequ( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(s), scond, + amax ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ppequ_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ppequ. Its overload differs for +// +template< typename MatrixAP, typename VectorS > +inline std::ptrdiff_t ppequ( const MatrixAP& ap, VectorS& s, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& scond, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& amax ) { + return ppequ_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, s, scond, amax ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pprfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/pprfs.hpp new file mode 100644 index 0000000..3d21837 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pprfs.hpp @@ -0,0 +1,428 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pprfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* ap, const float* afp, + const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, b, &ldb, + x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* ap, const double* afp, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, b, &ldb, + x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const std::complex* afp, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, b, &ldb, + x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const std::complex* afp, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, b, &ldb, + x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pprfs. +// +template< typename Value, typename Enable = void > +struct pprfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pprfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::pprfs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( ap, afp, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, afp, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pprfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::pprfs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( ap, afp, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, afp, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pprfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pprfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pprfs( const MatrixAP& ap, const MatrixAFP& afp, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return pprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, afp, b, x, ferr, berr, work ); +} + +// +// Overloaded function for pprfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixAFP, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +pprfs( const MatrixAP& ap, const MatrixAFP& afp, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return pprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, afp, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pptrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/pptrf.hpp new file mode 100644 index 0000000..0913fe9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pptrf.hpp @@ -0,0 +1,149 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pptrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrf( const UpLo, const fortran_int_t n, float* ap ) { + fortran_int_t info(0); + LAPACK_SPPTRF( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrf( const UpLo, const fortran_int_t n, double* ap ) { + fortran_int_t info(0); + LAPACK_DPPTRF( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrf( const UpLo, const fortran_int_t n, + std::complex* ap ) { + fortran_int_t info(0); + LAPACK_CPPTRF( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrf( const UpLo, const fortran_int_t n, + std::complex* ap ) { + fortran_int_t info(0); + LAPACK_ZPPTRF( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pptrf. +// +template< typename Value > +struct pptrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::pptrf( uplo(), bindings::size_column(ap), + bindings::begin_value(ap) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pptrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pptrf. Its overload differs for +// +template< typename MatrixAP > +inline std::ptrdiff_t pptrf( MatrixAP& ap ) { + return pptrf_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pptri.hpp b/sdk/boost/numeric/bindings/lapack/computational/pptri.hpp new file mode 100644 index 0000000..7aff4a1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pptri.hpp @@ -0,0 +1,149 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pptri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptri( const UpLo, const fortran_int_t n, float* ap ) { + fortran_int_t info(0); + LAPACK_SPPTRI( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptri( const UpLo, const fortran_int_t n, double* ap ) { + fortran_int_t info(0); + LAPACK_DPPTRI( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptri( const UpLo, const fortran_int_t n, + std::complex* ap ) { + fortran_int_t info(0); + LAPACK_CPPTRI( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptri( const UpLo, const fortran_int_t n, + std::complex* ap ) { + fortran_int_t info(0); + LAPACK_ZPPTRI( &lapack_option< UpLo >::value, &n, ap, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pptri. +// +template< typename Value > +struct pptri_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::pptri( uplo(), bindings::size_column(ap), + bindings::begin_value(ap) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pptri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pptri. Its overload differs for +// +template< typename MatrixAP > +inline std::ptrdiff_t pptri( MatrixAP& ap ) { + return pptri_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pptrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/pptrs.hpp new file mode 100644 index 0000000..e47e1ff --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pptrs.hpp @@ -0,0 +1,171 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PPTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pptrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* ap, float* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* ap, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pptrs. +// +template< typename Value > +struct pptrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixAP& ap, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::pptrs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pptrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pptrs. Its overload differs for +// +template< typename MatrixAP, typename MatrixB > +inline std::ptrdiff_t pptrs( const MatrixAP& ap, MatrixB& b ) { + return pptrs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pstrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/pstrf.hpp new file mode 100644 index 0000000..5933686 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pstrf.hpp @@ -0,0 +1,234 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PSTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PSTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pstrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pstrf( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, fortran_int_t* piv, fortran_int_t& rank, + const float tol, float* work ) { + fortran_int_t info(0); + LAPACK_SPSTRF( &lapack_option< UpLo >::value, &n, a, &lda, piv, &rank, + &tol, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pstrf( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, fortran_int_t* piv, fortran_int_t& rank, + const double tol, double* work ) { + fortran_int_t info(0); + LAPACK_DPSTRF( &lapack_option< UpLo >::value, &n, a, &lda, piv, &rank, + &tol, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pstrf( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* piv, + fortran_int_t& rank, const float tol, float* work ) { + fortran_int_t info(0); + LAPACK_CPSTRF( &lapack_option< UpLo >::value, &n, a, &lda, piv, &rank, + &tol, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pstrf( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* piv, + fortran_int_t& rank, const double tol, double* work ) { + fortran_int_t info(0); + LAPACK_ZPSTRF( &lapack_option< UpLo >::value, &n, a, &lda, piv, &rank, + &tol, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pstrf. +// +template< typename Value > +struct pstrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorPIV& piv, + fortran_int_t& rank, const real_type tol, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorPIV >::value) ); + BOOST_ASSERT( bindings::size(piv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::pstrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(piv), rank, tol, + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorPIV& piv, + fortran_int_t& rank, const real_type tol, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, piv, rank, tol, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorPIV& piv, + fortran_int_t& rank, const real_type tol, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, piv, rank, tol, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pstrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pstrf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pstrf( MatrixA& a, VectorPIV& piv, fortran_int_t& rank, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type tol, Workspace work ) { + return pstrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, piv, rank, tol, work ); +} + +// +// Overloaded function for pstrf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorPIV > +inline typename boost::disable_if< detail::is_workspace< VectorPIV >, + std::ptrdiff_t >::type +pstrf( MatrixA& a, VectorPIV& piv, fortran_int_t& rank, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type tol ) { + return pstrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, piv, rank, tol, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ptcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/ptcon.hpp new file mode 100644 index 0000000..b7f458b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ptcon.hpp @@ -0,0 +1,296 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ptcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ptcon( const fortran_int_t n, const float* d, + const float* e, const float anorm, float& rcond, float* work ) { + fortran_int_t info(0); + LAPACK_SPTCON( &n, d, e, &anorm, &rcond, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ptcon( const fortran_int_t n, const double* d, + const double* e, const double anorm, double& rcond, double* work ) { + fortran_int_t info(0); + LAPACK_DPTCON( &n, d, e, &anorm, &rcond, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptcon( const fortran_int_t n, const float* d, + const std::complex* e, const float anorm, float& rcond, + float* rwork ) { + fortran_int_t info(0); + LAPACK_CPTCON( &n, d, e, &anorm, &rcond, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptcon( const fortran_int_t n, const double* d, + const std::complex* e, const double anorm, double& rcond, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPTCON( &n, d, e, &anorm, &rcond, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ptcon. +// +template< typename Value, typename Enable = void > +struct ptcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ptcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename WORK > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const real_type anorm, real_type& rcond, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d) )); + return detail::ptcon( bindings::size(d), bindings::begin_value(d), + bindings::begin_value(e), anorm, rcond, + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d) ) ); + return invoke( d, e, anorm, rcond, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( d, e, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ptcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename RWORK > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const real_type anorm, real_type& rcond, detail::workspace1< + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size(d) )); + return detail::ptcon( bindings::size(d), bindings::begin_value(d), + bindings::begin_value(e), anorm, rcond, + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size(d) ) ); + return invoke( d, e, anorm, rcond, workspace( tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( d, e, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ptcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ptcon. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ptcon( const VectorD& d, const VectorE& e, + const typename remove_imaginary< typename bindings::value_type< + VectorE >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< VectorE >::type >::type& rcond, + Workspace work ) { + return ptcon_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e, anorm, rcond, work ); +} + +// +// Overloaded function for ptcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE > +inline typename boost::disable_if< detail::is_workspace< VectorE >, + std::ptrdiff_t >::type +ptcon( const VectorD& d, const VectorE& e, + const typename remove_imaginary< typename bindings::value_type< + VectorE >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< VectorE >::type >::type& rcond ) { + return ptcon_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pteqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/pteqr.hpp new file mode 100644 index 0000000..860e8f3 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pteqr.hpp @@ -0,0 +1,316 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTEQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTEQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pteqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t pteqr( const char compz, const fortran_int_t n, float* d, + float* e, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SPTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t pteqr( const char compz, const fortran_int_t n, + double* d, double* e, double* z, const fortran_int_t ldz, + double* work ) { + fortran_int_t info(0); + LAPACK_DPTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t pteqr( const char compz, const fortran_int_t n, float* d, + float* e, std::complex* z, const fortran_int_t ldz, + float* work ) { + fortran_int_t info(0); + LAPACK_CPTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t pteqr( const char compz, const fortran_int_t n, + double* d, double* e, std::complex* z, + const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_ZPTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pteqr. +// +template< typename Value, typename Enable = void > +struct pteqr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pteqr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d) )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' ); + return detail::pteqr( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d) ) ); + return invoke( compz, d, e, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( compz, d, e, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 4*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pteqr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d) )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' ); + return detail::pteqr( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d) ) ); + return invoke( compz, d, e, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( compz, d, e, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 4*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pteqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pteqr. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pteqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z, + Workspace work ) { + return pteqr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( compz, d, e, z, work ); +} + +// +// Overloaded function for pteqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +pteqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z ) { + return pteqr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( compz, d, e, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ptrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/ptrfs.hpp new file mode 100644 index 0000000..c9af937 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ptrfs.hpp @@ -0,0 +1,478 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ptrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ptrfs( const fortran_int_t n, const fortran_int_t nrhs, + const float* d, const float* e, const float* df, const float* ef, + const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work ) { + fortran_int_t info(0); + LAPACK_SPTRFS( &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, berr, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ptrfs( const fortran_int_t n, const fortran_int_t nrhs, + const double* d, const double* e, const double* df, const double* ef, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work ) { + fortran_int_t info(0); + LAPACK_DPTRFS( &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, berr, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptrfs( const char uplo, const fortran_int_t n, + const fortran_int_t nrhs, const float* d, + const std::complex* e, const float* df, + const std::complex* ef, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPTRFS( &uplo, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, + berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptrfs( const char uplo, const fortran_int_t n, + const fortran_int_t nrhs, const double* d, + const std::complex* e, const double* df, + const std::complex* ef, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPTRFS( &uplo, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, ferr, + berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ptrfs. +// +template< typename Value, typename Enable = void > +struct ptrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ptrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const VectorDF& df, const VectorEF& ef, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorEF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(df) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(ef) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + return detail::ptrfs( bindings::size(d), bindings::size_column(b), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(df), bindings::begin_value(ef), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const VectorDF& df, const VectorEF& ef, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d) ) ); + return invoke( d, e, df, ef, b, x, ferr, berr, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + const VectorDF& df, const VectorEF& ef, const MatrixB& b, + MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( d, e, df, ef, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ptrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const char uplo, const VectorD& d, + const VectorE& e, const VectorDF& df, const VectorEF& ef, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorEF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(df) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(ef) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size(d) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size(d) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + return detail::ptrfs( uplo, bindings::size(d), + bindings::size_column(b), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(df), + bindings::begin_value(ef), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char uplo, const VectorD& d, + const VectorE& e, const VectorDF& df, const VectorEF& ef, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size(d) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size(d) ) ); + return invoke( uplo, d, e, df, ef, b, x, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char uplo, const VectorD& d, + const VectorE& e, const VectorDF& df, const VectorEF& ef, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, d, e, df, ef, b, x, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ptrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ptrfs. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df, + const VectorEF& ef, const MatrixB& b, MatrixX& x, VectorFERR& ferr, + VectorBERR& berr, Workspace work ) { + return ptrfs_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e, df, ef, b, x, ferr, berr, work ); +} + +// +// Overloaded function for ptrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +ptrfs( const VectorD& d, const VectorE& e, const VectorDF& df, + const VectorEF& ef, const MatrixB& b, MatrixX& x, VectorFERR& ferr, + VectorBERR& berr ) { + return ptrfs_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e, df, ef, b, x, ferr, berr, + optimal_workspace() ); +} + +// +// Overloaded function for ptrfs. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ptrfs( const char uplo, const VectorD& d, const VectorE& e, + const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return ptrfs_impl< typename bindings::value_type< + VectorE >::type >::invoke( uplo, d, e, df, ef, b, x, ferr, berr, + work ); +} + +// +// Overloaded function for ptrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +ptrfs( const char uplo, const VectorD& d, const VectorE& e, + const VectorDF& df, const VectorEF& ef, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr ) { + return ptrfs_impl< typename bindings::value_type< + VectorE >::type >::invoke( uplo, d, e, df, ef, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pttrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/pttrf.hpp new file mode 100644 index 0000000..731d7bf --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pttrf.hpp @@ -0,0 +1,187 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pttrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t pttrf( const fortran_int_t n, float* d, float* e ) { + fortran_int_t info(0); + LAPACK_SPTTRF( &n, d, e, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t pttrf( const fortran_int_t n, double* d, double* e ) { + fortran_int_t info(0); + LAPACK_DPTTRF( &n, d, e, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t pttrf( const fortran_int_t n, float* d, + std::complex* e ) { + fortran_int_t info(0); + LAPACK_CPTTRF( &n, d, e, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t pttrf( const fortran_int_t n, double* d, + std::complex* e ) { + fortran_int_t info(0); + LAPACK_ZPTTRF( &n, d, e, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pttrf. +// +template< typename Value, typename Enable = void > +struct pttrf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pttrf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( VectorD& d, VectorE& e ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + return detail::pttrf( bindings::size(d), bindings::begin_value(d), + bindings::begin_value(e) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pttrf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( VectorD& d, VectorE& e ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + return detail::pttrf( bindings::size(d), bindings::begin_value(d), + bindings::begin_value(e) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pttrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pttrf. Its overload differs for +// +template< typename VectorD, typename VectorE > +inline std::ptrdiff_t pttrf( VectorD& d, VectorE& e ) { + return pttrf_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/pttrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/pttrs.hpp new file mode 100644 index 0000000..7cf377b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/pttrs.hpp @@ -0,0 +1,229 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_PTTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pttrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t pttrs( const fortran_int_t n, const fortran_int_t nrhs, + const float* d, const float* e, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPTTRS( &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t pttrs( const fortran_int_t n, const fortran_int_t nrhs, + const double* d, const double* e, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPTTRS( &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t pttrs( const char uplo, const fortran_int_t n, + const fortran_int_t nrhs, const float* d, + const std::complex* e, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPTTRS( &uplo, &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t pttrs( const char uplo, const fortran_int_t n, + const fortran_int_t nrhs, const double* d, + const std::complex* e, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPTTRS( &uplo, &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pttrs. +// +template< typename Value, typename Enable = void > +struct pttrs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pttrs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( const VectorD& d, const VectorE& e, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + return detail::pttrs( bindings::size(d), bindings::size_column(b), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pttrs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( const char uplo, const VectorD& d, + const VectorE& e, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + return detail::pttrs( uplo, bindings::size(d), + bindings::size_column(b), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pttrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pttrs. Its overload differs for +// +template< typename VectorD, typename VectorE, typename MatrixB > +inline std::ptrdiff_t pttrs( const VectorD& d, const VectorE& e, + MatrixB& b ) { + return pttrs_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e, b ); +} + +// +// Overloaded function for pttrs. Its overload differs for +// +template< typename VectorD, typename VectorE, typename MatrixB > +inline std::ptrdiff_t pttrs( const char uplo, const VectorD& d, + const VectorE& e, MatrixB& b ) { + return pttrs_impl< typename bindings::value_type< + VectorE >::type >::invoke( uplo, d, e, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sbgst.hpp b/sdk/boost/numeric/bindings/lapack/computational/sbgst.hpp new file mode 100644 index 0000000..687a6f8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sbgst.hpp @@ -0,0 +1,226 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SBGST_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SBGST_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbgst is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgst( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + float* ab, const fortran_int_t ldab, const float* bb, + const fortran_int_t ldbb, float* x, const fortran_int_t ldx, + float* work ) { + fortran_int_t info(0); + LAPACK_SSBGST( &vect, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, x, &ldx, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgst( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + double* ab, const fortran_int_t ldab, const double* bb, + const fortran_int_t ldbb, double* x, const fortran_int_t ldx, + double* work ) { + fortran_int_t info(0); + LAPACK_DSBGST( &vect, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, x, &ldx, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbgst. +// +template< typename Value > +struct sbgst_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX, + typename WORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( vect == 'N' || vect == 'V' ); + return detail::sbgst( vect, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(x), + bindings::stride_major(x), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( vect, ab, bb, x, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixX > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, + const MatrixBB& bb, MatrixX& x, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( vect, ab, bb, x, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbgst_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbgst. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename MatrixX, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbgst( const char vect, MatrixAB& ab, const MatrixBB& bb, MatrixX& x, + Workspace work ) { + return sbgst_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, bb, x, work ); +} + +// +// Overloaded function for sbgst. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename MatrixX > +inline typename boost::disable_if< detail::is_workspace< MatrixX >, + std::ptrdiff_t >::type +sbgst( const char vect, MatrixAB& ab, const MatrixBB& bb, MatrixX& x ) { + return sbgst_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, bb, x, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sbtrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/sbtrd.hpp new file mode 100644 index 0000000..de7f151 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sbtrd.hpp @@ -0,0 +1,230 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SBTRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SBTRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbtrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbtrd( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t kd, float* ab, + const fortran_int_t ldab, float* d, float* e, float* q, + const fortran_int_t ldq, float* work ) { + fortran_int_t info(0); + LAPACK_SSBTRD( &vect, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + d, e, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbtrd( const char vect, const UpLo, + const fortran_int_t n, const fortran_int_t kd, double* ab, + const fortran_int_t ldab, double* d, double* e, double* q, + const fortran_int_t ldq, double* work ) { + fortran_int_t info(0); + LAPACK_DSBTRD( &vect, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + d, e, q, &ldq, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbtrd. +// +template< typename Value > +struct sbtrd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename WORK > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( vect == 'N' || vect == 'V' || vect == 'U' ); + return detail::sbtrd( vect, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( vect, ab, d, e, q, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > + static std::ptrdiff_t invoke( const char vect, MatrixAB& ab, VectorD& d, + VectorE& e, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( vect, ab, d, e, q, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbtrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbtrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbtrd( const char vect, MatrixAB& ab, VectorD& d, VectorE& e, MatrixQ& q, + Workspace work ) { + return sbtrd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, d, e, q, work ); +} + +// +// Overloaded function for sbtrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorD, typename VectorE, + typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +sbtrd( const char vect, MatrixAB& ab, VectorD& d, VectorE& e, + MatrixQ& q ) { + return sbtrd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( vect, ab, d, e, q, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/spcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/spcon.hpp new file mode 100644 index 0000000..cea240c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/spcon.hpp @@ -0,0 +1,322 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spcon( const UpLo, const fortran_int_t n, + const float* ap, const fortran_int_t* ipiv, const float anorm, + float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spcon( const UpLo, const fortran_int_t n, + const double* ap, const fortran_int_t* ipiv, const double anorm, + double& rcond, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spcon( const UpLo, const fortran_int_t n, + const std::complex* ap, const fortran_int_t* ipiv, + const float anorm, float& rcond, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CSPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spcon( const UpLo, const fortran_int_t n, + const std::complex* ap, const fortran_int_t* ipiv, + const double anorm, double& rcond, std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZSPCON( &lapack_option< UpLo >::value, &n, ap, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spcon. +// +template< typename Value, typename Enable = void > +struct spcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct spcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::spcon( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), anorm, + rcond, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct spcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::spcon( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), anorm, + rcond, bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( ap, ipiv, anorm, rcond, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spcon( const MatrixAP& ap, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond, + Workspace work ) { + return spcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, anorm, rcond, work ); +} + +// +// Overloaded function for spcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +spcon( const MatrixAP& ap, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond ) { + return spcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sprfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/sprfs.hpp new file mode 100644 index 0000000..96a0821 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sprfs.hpp @@ -0,0 +1,439 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sprfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* ap, const float* afp, + const fortran_int_t* ipiv, const float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* ap, const double* afp, + const fortran_int_t* ipiv, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const std::complex* afp, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CSPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sprfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const std::complex* afp, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZSPRFS( &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, ipiv, b, + &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sprfs. +// +template< typename Value, typename Enable = void > +struct sprfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sprfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::sprfs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sprfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::sprfs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( ap, afp, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixAFP& afp, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, afp, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sprfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sprfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sprfs( const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return sprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, afp, ipiv, b, x, ferr, berr, + work ); +} + +// +// Overloaded function for sprfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +sprfs( const MatrixAP& ap, const MatrixAFP& afp, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return sprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, afp, ipiv, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sptrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/sptrd.hpp new file mode 100644 index 0000000..ed6d85b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sptrd.hpp @@ -0,0 +1,147 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sptrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrd( const UpLo, const fortran_int_t n, float* ap, + float* d, float* e, float* tau ) { + fortran_int_t info(0); + LAPACK_SSPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrd( const UpLo, const fortran_int_t n, double* ap, + double* d, double* e, double* tau ) { + fortran_int_t info(0); + LAPACK_DSPTRD( &lapack_option< UpLo >::value, &n, ap, d, e, tau, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sptrd. +// +template< typename Value > +struct sptrd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorD& d, VectorE& e, + VectorTAU& tau ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(ap)-1 ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::sptrd( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(tau) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sptrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sptrd. Its overload differs for +// +template< typename MatrixAP, typename VectorD, typename VectorE, + typename VectorTAU > +inline std::ptrdiff_t sptrd( MatrixAP& ap, VectorD& d, VectorE& e, + VectorTAU& tau ) { + return sptrd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, d, e, tau ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sptrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/sptrf.hpp new file mode 100644 index 0000000..ce4487f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sptrf.hpp @@ -0,0 +1,152 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sptrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrf( const UpLo, const fortran_int_t n, float* ap, + fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_SSPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrf( const UpLo, const fortran_int_t n, double* ap, + fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_DSPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrf( const UpLo, const fortran_int_t n, + std::complex* ap, fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_CSPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrf( const UpLo, const fortran_int_t n, + std::complex* ap, fortran_int_t* ipiv ) { + fortran_int_t info(0); + LAPACK_ZSPTRF( &lapack_option< UpLo >::value, &n, ap, ipiv, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sptrf. +// +template< typename Value > +struct sptrf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::sptrf( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sptrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sptrf. Its overload differs for +// +template< typename MatrixAP, typename VectorIPIV > +inline std::ptrdiff_t sptrf( MatrixAP& ap, VectorIPIV& ipiv ) { + return sptrf_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sptri.hpp b/sdk/boost/numeric/bindings/lapack/computational/sptri.hpp new file mode 100644 index 0000000..bdb86ea --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sptri.hpp @@ -0,0 +1,293 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sptri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptri( const UpLo, const fortran_int_t n, float* ap, + const fortran_int_t* ipiv, float* work ) { + fortran_int_t info(0); + LAPACK_SSPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptri( const UpLo, const fortran_int_t n, double* ap, + const fortran_int_t* ipiv, double* work ) { + fortran_int_t info(0); + LAPACK_DSPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptri( const UpLo, const fortran_int_t n, + std::complex* ap, const fortran_int_t* ipiv, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CSPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptri( const UpLo, const fortran_int_t n, + std::complex* ap, const fortran_int_t* ipiv, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZSPTRI( &lapack_option< UpLo >::value, &n, ap, ipiv, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sptri. +// +template< typename Value, typename Enable = void > +struct sptri_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sptri_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::sptri( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( ap, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sptri_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::sptri( uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( ap, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixAP& ap, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( ap, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sptri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sptri. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sptri( MatrixAP& ap, const VectorIPIV& ipiv, Workspace work ) { + return sptri_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, work ); +} + +// +// Overloaded function for sptri. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +sptri( MatrixAP& ap, const VectorIPIV& ipiv ) { + return sptri_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sptrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/sptrs.hpp new file mode 100644 index 0000000..3da99e6 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sptrs.hpp @@ -0,0 +1,177 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SPTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sptrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* ap, const fortran_int_t* ipiv, + float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* ap, const fortran_int_t* ipiv, + double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CSPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sptrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* ap, + const fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZSPTRS( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sptrs. +// +template< typename Value > +struct sptrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixAP& ap, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::sptrs( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sptrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sptrs. Its overload differs for +// +template< typename MatrixAP, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t sptrs( const MatrixAP& ap, const VectorIPIV& ipiv, + MatrixB& b ) { + return sptrs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/stebz.hpp b/sdk/boost/numeric/bindings/lapack/computational/stebz.hpp new file mode 100644 index 0000000..843cc77 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/stebz.hpp @@ -0,0 +1,262 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEBZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEBZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stebz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stebz( const char range, const char order, + const fortran_int_t n, const float vl, const float vu, + const fortran_int_t il, const fortran_int_t iu, const float abstol, + const float* d, const float* e, fortran_int_t& m, + fortran_int_t& nsplit, float* w, fortran_int_t* iblock, + fortran_int_t* isplit, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSTEBZ( &range, &order, &n, &vl, &vu, &il, &iu, &abstol, d, e, &m, + &nsplit, w, iblock, isplit, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stebz( const char range, const char order, + const fortran_int_t n, const double vl, const double vu, + const fortran_int_t il, const fortran_int_t iu, const double abstol, + const double* d, const double* e, fortran_int_t& m, + fortran_int_t& nsplit, double* w, fortran_int_t* iblock, + fortran_int_t* isplit, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSTEBZ( &range, &order, &n, &vl, &vu, &il, &iu, &abstol, d, e, &m, + &nsplit, w, iblock, isplit, work, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stebz. +// +template< typename Value > +struct stebz_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char range, const char order, + const fortran_int_t n, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, const VectorD& d, const VectorE& e, + fortran_int_t& m, fortran_int_t& nsplit, VectorW& w, + VectorIBLOCK& iblock, VectorISPLIT& isplit, detail::workspace2< + WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIBLOCK >::type >::type, + typename remove_const< typename bindings::value_type< + VectorISPLIT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIBLOCK >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISPLIT >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(isplit) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( order == 'B' || order == 'E' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stebz( range, order, n, vl, vu, il, iu, abstol, + bindings::begin_value(d), bindings::begin_value(e), m, nsplit, + bindings::begin_value(w), bindings::begin_value(iblock), + bindings::begin_value(isplit), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT > + static std::ptrdiff_t invoke( const char range, const char order, + const fortran_int_t n, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, const VectorD& d, const VectorE& e, + fortran_int_t& m, fortran_int_t& nsplit, VectorW& w, + VectorIBLOCK& iblock, VectorISPLIT& isplit, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( range, order, n, vl, vu, il, iu, abstol, d, e, m, + nsplit, w, iblock, isplit, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT > + static std::ptrdiff_t invoke( const char range, const char order, + const fortran_int_t n, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, const VectorD& d, const VectorE& e, + fortran_int_t& m, fortran_int_t& nsplit, VectorW& w, + VectorIBLOCK& iblock, VectorISPLIT& isplit, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( range, order, n, vl, vu, il, iu, abstol, d, e, m, + nsplit, w, iblock, isplit, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 4*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 3*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stebz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stebz. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stebz( const char range, const char order, const fortran_int_t n, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type abstol, const VectorD& d, const VectorE& e, + fortran_int_t& m, fortran_int_t& nsplit, VectorW& w, + VectorIBLOCK& iblock, VectorISPLIT& isplit, Workspace work ) { + return stebz_impl< typename bindings::value_type< + VectorD >::type >::invoke( range, order, n, vl, vu, il, iu, + abstol, d, e, m, nsplit, w, iblock, isplit, work ); +} + +// +// Overloaded function for stebz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT > +inline typename boost::disable_if< detail::is_workspace< VectorISPLIT >, + std::ptrdiff_t >::type +stebz( const char range, const char order, const fortran_int_t n, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type abstol, const VectorD& d, const VectorE& e, + fortran_int_t& m, fortran_int_t& nsplit, VectorW& w, + VectorIBLOCK& iblock, VectorISPLIT& isplit ) { + return stebz_impl< typename bindings::value_type< + VectorD >::type >::invoke( range, order, n, vl, vu, il, iu, + abstol, d, e, m, nsplit, w, iblock, isplit, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/stedc.hpp b/sdk/boost/numeric/bindings/lapack/computational/stedc.hpp new file mode 100644 index 0000000..3c3975b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/stedc.hpp @@ -0,0 +1,432 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEDC_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEDC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stedc is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stedc( const char compz, const fortran_int_t n, float* d, + float* e, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stedc( const char compz, const fortran_int_t n, + double* d, double* e, double* z, const fortran_int_t ldz, + double* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stedc( const char compz, const fortran_int_t n, float* d, + float* e, std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, float* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, rwork, &lrwork, + iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stedc( const char compz, const fortran_int_t n, + double* d, double* e, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, double* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZSTEDC( &compz, &n, d, e, z, &ldz, work, &lwork, rwork, &lrwork, + iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stedc. +// +template< typename Value, typename Enable = void > +struct stedc_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct stedc_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( compz, bindings::size(d) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( compz, bindings::size(d) )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + return detail::stedc( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( compz, + bindings::size(d) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( compz, bindings::size(d) ) ); + return invoke( compz, d, e, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stedc( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( compz, d, e, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char compz, + const std::ptrdiff_t n ) { + if ( compz == 'N' || n <= 1 ) { + return 1; + } else if ( compz == 'V' ) { + return 1 + 3*n + 2*n*static_cast(std::ceil(std::log( + n)/std::log(2))) + 3*n*n; + } else { // compz == 'I' + return 1 + 4*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char compz, + const std::ptrdiff_t n ) { + if ( compz == 'N' || n <= 1 ) { + return 1; + } else if ( compz == 'V' ) { + return 6 + 6*n + 5*n*static_cast(std::ceil(std::log( + n)/std::log(2))); + } else { // compz == 'I' + return 3 + 5*n; + } + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct stedc_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( compz, bindings::size(d) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( compz, bindings::size(d) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( compz, bindings::size(d) )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( compz == 'N' || compz == 'I' || compz == 'V' ); + return detail::stedc( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( compz, + bindings::size(d) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( compz, + bindings::size(d) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( compz, bindings::size(d) ) ); + return invoke( compz, d, e, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::stedc( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( compz, d, e, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char compz, + const std::ptrdiff_t n ) { + if ( compz == 'N' || compz == 'I' || n <= 1 ) { + return 1; + } else { // compz == 'V' + return n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char compz, + const std::ptrdiff_t n ) { + if ( compz == 'N' || n <= 1 ) { + return 1; + } else if ( compz == 'V' ) { + return 1 + 3*n + 2*n*static_cast(std::ceil(std::log( + n)/std::log(2))) + 3*n*n; + } else { // compz == 'I' + return 1 + 4*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char compz, + const std::ptrdiff_t n ) { + if ( compz == 'N' || n <= 1 ) { + return 1; + } else if ( compz == 'V' ) { + return 6 + 6*n + 5*n*static_cast(std::ceil(std::log( + n)/std::log(2))); + } else { // compz == 'I' + return 3 + 5*n; + } + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stedc_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stedc. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stedc( const char compz, VectorD& d, VectorE& e, MatrixZ& z, + Workspace work ) { + return stedc_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( compz, d, e, z, work ); +} + +// +// Overloaded function for stedc. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +stedc( const char compz, VectorD& d, VectorE& e, MatrixZ& z ) { + return stedc_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( compz, d, e, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/stegr.hpp b/sdk/boost/numeric/bindings/lapack/computational/stegr.hpp new file mode 100644 index 0000000..fbb194f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/stegr.hpp @@ -0,0 +1,481 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEGR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEGR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stegr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stegr( const char jobz, const char range, + const fortran_int_t n, float* d, float* e, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, float* z, + const fortran_int_t ldz, fortran_int_t* isuppz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stegr( const char jobz, const char range, + const fortran_int_t n, double* d, double* e, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, double* z, + const fortran_int_t ldz, fortran_int_t* isuppz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stegr( const char jobz, const char range, + const fortran_int_t n, float* d, float* e, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, + std::complex* z, const fortran_int_t ldz, + fortran_int_t* isuppz, float* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stegr( const char jobz, const char range, + const fortran_int_t n, double* d, double* e, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, + std::complex* z, const fortran_int_t ldz, + fortran_int_t* isuppz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZSTEGR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stegr. +// +template< typename Value, typename Enable = void > +struct stegr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct stegr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n, jobz )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n, jobz )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stegr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), bindings::begin_value(isuppz), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n, + jobz ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n, jobz ) ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stegr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), bindings::begin_value(isuppz), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 18*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 12*n ); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 8*n ); + } + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct stegr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n, jobz )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n, jobz )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stegr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), bindings::begin_value(isuppz), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n, + jobz ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n, jobz ) ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stegr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), bindings::begin_value(isuppz), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 18*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 12*n ); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 8*n ); + } + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stegr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stegr. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stegr( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< MatrixZ >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixZ >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixZ >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz, + Workspace work ) { + return stegr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + abstol, m, w, z, isuppz, work ); +} + +// +// Overloaded function for stegr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > +inline typename boost::disable_if< detail::is_workspace< VectorISUPPZ >, + std::ptrdiff_t >::type +stegr( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< MatrixZ >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixZ >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixZ >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz ) { + return stegr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + abstol, m, w, z, isuppz, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/stein.hpp b/sdk/boost/numeric/bindings/lapack/computational/stein.hpp new file mode 100644 index 0000000..ea45c81 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/stein.hpp @@ -0,0 +1,423 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEIN_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEIN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stein is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stein( const fortran_int_t n, const float* d, + const float* e, const fortran_int_t m, const float* w, + const fortran_int_t* iblock, const fortran_int_t* isplit, float* z, + const fortran_int_t ldz, float* work, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stein( const fortran_int_t n, const double* d, + const double* e, const fortran_int_t m, const double* w, + const fortran_int_t* iblock, const fortran_int_t* isplit, double* z, + const fortran_int_t ldz, double* work, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stein( const fortran_int_t n, const float* d, + const float* e, const fortran_int_t m, const float* w, + const fortran_int_t* iblock, const fortran_int_t* isplit, + std::complex* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stein( const fortran_int_t n, const double* d, + const double* e, const fortran_int_t m, const double* w, + const fortran_int_t* iblock, const fortran_int_t* isplit, + std::complex* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZSTEIN( &n, d, e, &m, w, iblock, isplit, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stein. +// +template< typename Value, typename Enable = void > +struct stein_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct stein_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorE& e, const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIBLOCK >::type >::type, + typename remove_const< typename bindings::value_type< + VectorISPLIT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIBLOCK >::type >::type, + typename remove_const< typename bindings::value_type< + VectorIFAIL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(isplit) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(z) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::stein( n, bindings::begin_value(d), + bindings::begin_value(e), m, bindings::begin_value(w), + bindings::begin_value(iblock), bindings::begin_value(isplit), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorE& e, const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( n, d, e, m, w, iblock, isplit, z, ifail, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorE& e, const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( n, d, e, m, w, iblock, isplit, z, ifail, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 5*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct stein_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorE& e, const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIBLOCK >::type >::type, + typename remove_const< typename bindings::value_type< + VectorISPLIT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorIBLOCK >::type >::type, + typename remove_const< typename bindings::value_type< + VectorIFAIL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(isplit) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(z) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::stein( n, bindings::begin_value(d), + bindings::begin_value(e), m, bindings::begin_value(w), + bindings::begin_value(iblock), bindings::begin_value(isplit), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorE& e, const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( n, d, e, m, w, iblock, isplit, z, ifail, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t n, const VectorD& d, + const VectorE& e, const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( n, d, e, m, w, iblock, isplit, z, ifail, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 5*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stein_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stein. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stein( const fortran_int_t n, const VectorD& d, const VectorE& e, + const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, MatrixZ& z, + VectorIFAIL& ifail, Workspace work ) { + return stein_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( n, d, e, m, w, iblock, isplit, z, + ifail, work ); +} + +// +// Overloaded function for stein. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorW, + typename VectorIBLOCK, typename VectorISPLIT, typename MatrixZ, + typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +stein( const fortran_int_t n, const VectorD& d, const VectorE& e, + const fortran_int_t m, const VectorW& w, + const VectorIBLOCK& iblock, const VectorISPLIT& isplit, MatrixZ& z, + VectorIFAIL& ifail ) { + return stein_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( n, d, e, m, w, iblock, isplit, z, + ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/stemr.hpp b/sdk/boost/numeric/bindings/lapack/computational/stemr.hpp new file mode 100644 index 0000000..c941bd6 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/stemr.hpp @@ -0,0 +1,486 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEMR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEMR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stemr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stemr( const char jobz, const char range, + const fortran_int_t n, float* d, float* e, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, float* w, float* z, const fortran_int_t ldz, + const fortran_int_t nzc, fortran_int_t* isuppz, + fortran_bool_t& tryrac, float* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z, + &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stemr( const char jobz, const char range, + const fortran_int_t n, double* d, double* e, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, double* w, double* z, const fortran_int_t ldz, + const fortran_int_t nzc, fortran_int_t* isuppz, + fortran_bool_t& tryrac, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z, + &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stemr( const char jobz, const char range, + const fortran_int_t n, float* d, float* e, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, float* w, std::complex* z, + const fortran_int_t ldz, const fortran_int_t nzc, + fortran_int_t* isuppz, fortran_bool_t& tryrac, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z, + &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t stemr( const char jobz, const char range, + const fortran_int_t n, double* d, double* e, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, double* w, std::complex* z, + const fortran_int_t ldz, const fortran_int_t nzc, + fortran_int_t* isuppz, fortran_bool_t& tryrac, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZSTEMR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &m, w, z, + &ldz, &nzc, isuppz, &tryrac, work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stemr. +// +template< typename Value, typename Enable = void > +struct stemr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct stemr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, VectorW& w, MatrixZ& z, + const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n, jobz )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n, jobz )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stemr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), nzc, bindings::begin_value(isuppz), + tryrac, bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, VectorW& w, MatrixZ& z, + const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n, + jobz ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n, jobz ) ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, m, w, z, nzc, + isuppz, tryrac, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, VectorW& w, MatrixZ& z, + const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stemr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), nzc, bindings::begin_value(isuppz), + tryrac, &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, m, w, z, nzc, + isuppz, tryrac, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 18*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 12*n ); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 8*n ); + } + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct stemr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, VectorW& w, MatrixZ& z, + const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= n ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n, jobz )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n, jobz )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stemr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), nzc, bindings::begin_value(isuppz), + tryrac, bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, VectorW& w, MatrixZ& z, + const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n, + jobz ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n, jobz ) ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, m, w, z, nzc, + isuppz, tryrac, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + fortran_int_t& m, VectorW& w, MatrixZ& z, + const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stemr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), nzc, bindings::begin_value(isuppz), + tryrac, &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, m, w, z, nzc, + isuppz, tryrac, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 18*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 12*n ); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char jobz ) { + if ( jobz == 'V' ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } else { + return std::max< std::ptrdiff_t >( 1, 8*n ); + } + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stemr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stemr. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stemr( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< MatrixZ >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixZ >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, fortran_int_t& m, VectorW& w, + MatrixZ& z, const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac, Workspace work ) { + return stemr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + m, w, z, nzc, isuppz, tryrac, work ); +} + +// +// Overloaded function for stemr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > +inline typename boost::disable_if< detail::is_workspace< VectorISUPPZ >, + std::ptrdiff_t >::type +stemr( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< MatrixZ >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixZ >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, fortran_int_t& m, VectorW& w, + MatrixZ& z, const fortran_int_t nzc, VectorISUPPZ& isuppz, + fortran_bool_t& tryrac ) { + return stemr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + m, w, z, nzc, isuppz, tryrac, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/steqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/steqr.hpp new file mode 100644 index 0000000..94be533 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/steqr.hpp @@ -0,0 +1,324 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STEQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for steqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t steqr( const char compz, const fortran_int_t n, float* d, + float* e, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t steqr( const char compz, const fortran_int_t n, + double* d, double* e, double* z, const fortran_int_t ldz, + double* work ) { + fortran_int_t info(0); + LAPACK_DSTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t steqr( const char compz, const fortran_int_t n, float* d, + float* e, std::complex* z, const fortran_int_t ldz, + float* work ) { + fortran_int_t info(0); + LAPACK_CSTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t steqr( const char compz, const fortran_int_t n, + double* d, double* e, std::complex* z, + const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_ZSTEQR( &compz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to steqr. +// +template< typename Value, typename Enable = void > +struct steqr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct steqr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d), compz )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' ); + return detail::steqr( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d), compz ) ); + return invoke( compz, d, e, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( compz, d, e, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char compz ) { + if ( compz == 'N' ) { + return 1; + } else { + return std::max< std::ptrdiff_t >( 1, 2*n-2 ); + } + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct steqr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d), compz )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( compz == 'N' || compz == 'V' || compz == 'I' ); + return detail::steqr( compz, bindings::size(d), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d), compz ) ); + return invoke( compz, d, e, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char compz, VectorD& d, VectorE& e, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( compz, d, e, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char compz ) { + if ( compz == 'N' ) { + return 1; + } else { + return std::max< std::ptrdiff_t >( 1, 2*n-2 ); + } + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the steqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for steqr. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +steqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z, + Workspace work ) { + return steqr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( compz, d, e, z, work ); +} + +// +// Overloaded function for steqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +steqr( const char compz, VectorD& d, VectorE& e, MatrixZ& z ) { + return steqr_impl< typename bindings::value_type< + MatrixZ >::type >::invoke( compz, d, e, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sterf.hpp b/sdk/boost/numeric/bindings/lapack/computational/sterf.hpp new file mode 100644 index 0000000..8ee0070 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sterf.hpp @@ -0,0 +1,127 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STERF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_STERF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sterf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t sterf( const fortran_int_t n, float* d, float* e ) { + fortran_int_t info(0); + LAPACK_SSTERF( &n, d, e, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t sterf( const fortran_int_t n, double* d, double* e ) { + fortran_int_t info(0); + LAPACK_DSTERF( &n, d, e, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sterf. +// +template< typename Value > +struct sterf_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorD& d, + VectorE& e ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( n >= 0 ); + return detail::sterf( n, bindings::begin_value(d), + bindings::begin_value(e) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sterf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sterf. Its overload differs for +// +template< typename VectorD, typename VectorE > +inline std::ptrdiff_t sterf( const fortran_int_t n, VectorD& d, + VectorE& e ) { + return sterf_impl< typename bindings::value_type< + VectorD >::type >::invoke( n, d, e ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sycon.hpp b/sdk/boost/numeric/bindings/lapack/computational/sycon.hpp new file mode 100644 index 0000000..40963a4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sycon.hpp @@ -0,0 +1,338 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sycon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sycon( const UpLo, const fortran_int_t n, const float* a, + const fortran_int_t lda, const fortran_int_t* ipiv, const float anorm, + float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSYCON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sycon( const UpLo, const fortran_int_t n, + const double* a, const fortran_int_t lda, const fortran_int_t* ipiv, + const double anorm, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSYCON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sycon( const UpLo, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, const float anorm, float& rcond, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CSYCON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sycon( const UpLo, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, const double anorm, double& rcond, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZSYCON( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, &anorm, + &rcond, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sycon. +// +template< typename Value, typename Enable = void > +struct sycon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sycon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sycon( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), anorm, rcond, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( a, ipiv, anorm, rcond, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sycon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sycon( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), anorm, rcond, + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, anorm, rcond, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + const real_type anorm, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, anorm, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sycon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sycon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sycon( const MatrixA& a, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + Workspace work ) { + return sycon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, anorm, rcond, work ); +} + +// +// Overloaded function for sycon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +sycon( const MatrixA& a, const VectorIPIV& ipiv, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type anorm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond ) { + return sycon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, anorm, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sygst.hpp b/sdk/boost/numeric/bindings/lapack/computational/sygst.hpp new file mode 100644 index 0000000..18dcf45 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sygst.hpp @@ -0,0 +1,147 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYGST_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYGST_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sygst is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygst( const fortran_int_t itype, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, + const float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSYGST( &itype, &lapack_option< UpLo >::value, &n, a, &lda, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygst( const fortran_int_t itype, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, + const double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSYGST( &itype, &lapack_option< UpLo >::value, &n, a, &lda, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sygst. +// +template< typename Value > +struct sygst_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( const fortran_int_t itype, MatrixA& a, + const MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sygst( itype, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sygst_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sygst. Its overload differs for +// +template< typename MatrixA, typename MatrixB > +inline std::ptrdiff_t sygst( const fortran_int_t itype, MatrixA& a, + const MatrixB& b ) { + return sygst_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, a, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/syrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/syrfs.hpp new file mode 100644 index 0000000..4b92f0b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/syrfs.hpp @@ -0,0 +1,464 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for syrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syrfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const float* af, const fortran_int_t ldaf, const fortran_int_t* ipiv, + const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSYRFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syrfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const double* af, const fortran_int_t ldaf, const fortran_int_t* ipiv, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSYRFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syrfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CSYRFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syrfs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const std::complex* af, + const fortran_int_t ldaf, const fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZSYRFS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, af, + &ldaf, ipiv, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syrfs. +// +template< typename Value, typename Enable = void > +struct syrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct syrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::syrfs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct syrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::syrfs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, af, ipiv, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixAF& af, + const VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, af, ipiv, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the syrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syrfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +syrfs( const MatrixA& a, const MatrixAF& af, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return syrfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, ipiv, b, x, ferr, berr, work ); +} + +// +// Overloaded function for syrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +syrfs( const MatrixA& a, const MatrixAF& af, const VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return syrfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, af, ipiv, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sytrd.hpp b/sdk/boost/numeric/bindings/lapack/computational/sytrd.hpp new file mode 100644 index 0000000..b6788b1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sytrd.hpp @@ -0,0 +1,228 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sytrd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrd( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, float* d, float* e, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYTRD( &lapack_option< UpLo >::value, &n, a, &lda, d, e, tau, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrd( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, double* d, double* e, double* tau, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYTRD( &lapack_option< UpLo >::value, &n, a, &lda, d, e, tau, + work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sytrd. +// +template< typename Value > +struct sytrd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(a)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sytrd( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work() ); + return invoke( a, d, e, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorD& d, VectorE& e, + VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::sytrd( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, d, e, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sytrd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sytrd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sytrd( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau, + Workspace work ) { + return sytrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tau, work ); +} + +// +// Overloaded function for sytrd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorD, typename VectorE, + typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +sytrd( MatrixA& a, VectorD& d, VectorE& e, VectorTAU& tau ) { + return sytrd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, d, e, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sytrf.hpp b/sdk/boost/numeric/bindings/lapack/computational/sytrf.hpp new file mode 100644 index 0000000..3b33986 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sytrf.hpp @@ -0,0 +1,325 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sytrf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrf( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, fortran_int_t* ipiv, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYTRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrf( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, fortran_int_t* ipiv, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYTRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrf( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* ipiv, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CSYTRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrf( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t* ipiv, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZSYTRF( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sytrf. +// +template< typename Value, typename Enable = void > +struct sytrf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sytrf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sytrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::sytrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sytrf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sytrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + detail::sytrf( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sytrf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sytrf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sytrf( MatrixA& a, VectorIPIV& ipiv, Workspace work ) { + return sytrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, work ); +} + +// +// Overloaded function for sytrf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +sytrf( MatrixA& a, VectorIPIV& ipiv ) { + return sytrf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sytri.hpp b/sdk/boost/numeric/bindings/lapack/computational/sytri.hpp new file mode 100644 index 0000000..1ff2087 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sytri.hpp @@ -0,0 +1,310 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sytri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytri( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, const fortran_int_t* ipiv, float* work ) { + fortran_int_t info(0); + LAPACK_SSYTRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytri( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, const fortran_int_t* ipiv, double* work ) { + fortran_int_t info(0); + LAPACK_DSYTRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytri( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, std::complex* work ) { + fortran_int_t info(0); + LAPACK_CSYTRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytri( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const fortran_int_t* ipiv, std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZSYTRI( &lapack_option< UpLo >::value, &n, a, &lda, ipiv, work, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sytri. +// +template< typename Value, typename Enable = void > +struct sytri_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sytri_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sytri( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sytri_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sytri( uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(ipiv), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, ipiv, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV > + static std::ptrdiff_t invoke( MatrixA& a, const VectorIPIV& ipiv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, ipiv, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sytri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sytri. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sytri( MatrixA& a, const VectorIPIV& ipiv, Workspace work ) { + return sytri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, work ); +} + +// +// Overloaded function for sytri. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV > +inline typename boost::disable_if< detail::is_workspace< VectorIPIV >, + std::ptrdiff_t >::type +sytri( MatrixA& a, const VectorIPIV& ipiv ) { + return sytri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/sytrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/sytrs.hpp new file mode 100644 index 0000000..765005c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/sytrs.hpp @@ -0,0 +1,182 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_SYTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sytrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const float* a, const fortran_int_t lda, + const fortran_int_t* ipiv, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSYTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const double* a, const fortran_int_t lda, + const fortran_int_t* ipiv, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSYTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CSYTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sytrs( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, const fortran_int_t* ipiv, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZSYTRS( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sytrs. +// +template< typename Value > +struct sytrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixA& a, const VectorIPIV& ipiv, + MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sytrs( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sytrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sytrs. Its overload differs for +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t sytrs( const MatrixA& a, const VectorIPIV& ipiv, + MatrixB& b ) { + return sytrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tbcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/tbcon.hpp new file mode 100644 index 0000000..fdb6ef2 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tbcon.hpp @@ -0,0 +1,353 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tbcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tbcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const fortran_int_t kd, const float* ab, + const fortran_int_t ldab, float& rcond, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STBCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, &kd, ab, &ldab, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tbcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const fortran_int_t kd, const double* ab, + const fortran_int_t ldab, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTBCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, &kd, ab, &ldab, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tbcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const std::complex* ab, const fortran_int_t ldab, float& rcond, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CTBCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, &kd, ab, &ldab, &rcond, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tbcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const std::complex* ab, const fortran_int_t ldab, + double& rcond, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTBCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, &kd, ab, &ldab, &rcond, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tbcon. +// +template< typename Value, typename Enable = void > +struct tbcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tbcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd, + const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= kd+1 ); + BOOST_ASSERT( kd >= 0 ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::tbcon( norm, uplo(), diag(), bindings::size_column(ab), + kd, bindings::begin_value(ab), bindings::stride_major(ab), + rcond, bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd, + const MatrixAB& ab, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( norm, kd, ab, rcond, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd, + const MatrixAB& ab, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + return invoke( norm, kd, ab, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tbcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd, + const MatrixAB& ab, real_type& rcond, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= kd+1 ); + BOOST_ASSERT( kd >= 0 ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::tbcon( norm, uplo(), diag(), bindings::size_column(ab), + kd, bindings::begin_value(ab), bindings::stride_major(ab), + rcond, bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd, + const MatrixAB& ab, real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( norm, kd, ab, rcond, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB > + static std::ptrdiff_t invoke( const char norm, const fortran_int_t kd, + const MatrixAB& ab, real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + return invoke( norm, kd, ab, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tbcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tbcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tbcon( const char norm, const fortran_int_t kd, const MatrixAB& ab, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rcond, Workspace work ) { + return tbcon_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, kd, ab, rcond, work ); +} + +// +// Overloaded function for tbcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB > +inline typename boost::disable_if< detail::is_workspace< MatrixAB >, + std::ptrdiff_t >::type +tbcon( const char norm, const fortran_int_t kd, const MatrixAB& ab, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rcond ) { + return tbcon_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( norm, kd, ab, rcond, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tbrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/tbrfs.hpp new file mode 100644 index 0000000..bff1a6c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tbrfs.hpp @@ -0,0 +1,458 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tbrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const float* ab, const fortran_int_t ldab, + const float* b, const fortran_int_t ldb, const float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STBRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const double* ab, const fortran_int_t ldab, + const double* b, const fortran_int_t ldb, const double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTBRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, const std::complex* b, + const fortran_int_t ldb, const std::complex* x, + const fortran_int_t ldx, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CTBRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, const std::complex* b, + const fortran_int_t ldb, const std::complex* x, + const fortran_int_t ldx, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTBRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tbrfs. +// +template< typename Value, typename Enable = void > +struct tbrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tbrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= kd+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( kd >= 0 ); + return detail::tbrfs( uplo(), trans(), diag(), + bindings::size_column_op(ab, trans()), kd, + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(ab, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(ab, trans()) ) ); + return invoke( kd, ab, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + return invoke( kd, ab, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tbrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= kd+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( kd >= 0 ); + return detail::tbrfs( uplo(), trans(), diag(), + bindings::size_column_op(ab, trans()), kd, + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(ab, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(ab, trans()) ) ); + return invoke( kd, ab, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + return invoke( kd, ab, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tbrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tbrfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tbrfs( const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return tbrfs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( kd, ab, b, x, ferr, berr, work ); +} + +// +// Overloaded function for tbrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +tbrfs( const fortran_int_t kd, const MatrixAB& ab, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr ) { + return tbrfs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( kd, ab, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tbtrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/tbtrs.hpp new file mode 100644 index 0000000..a7e56b1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tbtrs.hpp @@ -0,0 +1,194 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TBTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tbtrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const float* ab, const fortran_int_t ldab, + float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_STBTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const double* ab, const fortran_int_t ldab, + double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DTBTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CTBTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tbtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, const std::complex* ab, + const fortran_int_t ldab, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZTBTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &kd, &nrhs, ab, + &ldab, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tbtrs. +// +template< typename Value > +struct tbtrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixB > + static std::ptrdiff_t invoke( const fortran_int_t kd, + const MatrixAB& ab, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAB, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAB >::type diag; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= kd+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( kd >= 0 ); + return detail::tbtrs( uplo(), trans(), diag(), + bindings::size_column_op(ab, trans()), kd, + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tbtrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tbtrs. Its overload differs for +// +template< typename MatrixAB, typename MatrixB > +inline std::ptrdiff_t tbtrs( const fortran_int_t kd, + const MatrixAB& ab, MatrixB& b ) { + return tbtrs_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( kd, ab, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tftri.hpp b/sdk/boost/numeric/bindings/lapack/computational/tftri.hpp new file mode 100644 index 0000000..0bcaf73 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tftri.hpp @@ -0,0 +1,162 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TFTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TFTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tftri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename TransR, typename UpLo, typename Diag > +inline std::ptrdiff_t tftri( const TransR, const UpLo, const Diag, + const fortran_int_t n, float* a ) { + fortran_int_t info(0); + LAPACK_STFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &lapack_option< Diag >::value, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename TransR, typename UpLo, typename Diag > +inline std::ptrdiff_t tftri( const TransR, const UpLo, const Diag, + const fortran_int_t n, double* a ) { + fortran_int_t info(0); + LAPACK_DTFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &lapack_option< Diag >::value, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR, typename UpLo, typename Diag > +inline std::ptrdiff_t tftri( const TransR, const UpLo, const Diag, + const fortran_int_t n, std::complex* a ) { + fortran_int_t info(0); + LAPACK_CTFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &lapack_option< Diag >::value, &n, a, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename TransR, typename UpLo, typename Diag > +inline std::ptrdiff_t tftri( const TransR, const UpLo, const Diag, + const fortran_int_t n, std::complex* a ) { + fortran_int_t info(0); + LAPACK_ZTFTRI( &lapack_option< TransR >::value, &lapack_option< + UpLo >::value, &lapack_option< Diag >::value, &n, a, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tftri. +// +template< typename Value > +struct tftri_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA > + static std::ptrdiff_t invoke( MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename blas::detail::default_order< MatrixA >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type transr; + typedef typename result_of::uplo_tag< MatrixA, transr >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column_op(a, transr()) >= 0 ); + return detail::tftri( transr(), uplo(), diag(), + bindings::size_column_op(a, transr()), + bindings::begin_value(a) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tftri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tftri. Its overload differs for +// +template< typename MatrixA > +inline std::ptrdiff_t tftri( MatrixA& a ) { + return tftri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tgevc.hpp b/sdk/boost/numeric/bindings/lapack/computational/tgevc.hpp new file mode 100644 index 0000000..be91db2 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tgevc.hpp @@ -0,0 +1,421 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGEVC_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGEVC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tgevc is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t tgevc( const Side, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, const float* s, + const fortran_int_t lds, const float* p, const fortran_int_t ldp, + float* vl, const fortran_int_t ldvl, float* vr, + const fortran_int_t ldvr, const fortran_int_t mm, fortran_int_t& m, + float* work ) { + fortran_int_t info(0); + LAPACK_STGEVC( &lapack_option< Side >::value, &howmny, select, &n, s, + &lds, p, &ldp, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t tgevc( const Side, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, const double* s, + const fortran_int_t lds, const double* p, const fortran_int_t ldp, + double* vl, const fortran_int_t ldvl, double* vr, + const fortran_int_t ldvr, const fortran_int_t mm, fortran_int_t& m, + double* work ) { + fortran_int_t info(0); + LAPACK_DTGEVC( &lapack_option< Side >::value, &howmny, select, &n, s, + &lds, p, &ldp, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t tgevc( const Side, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* s, const fortran_int_t lds, + const std::complex* p, const fortran_int_t ldp, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + const fortran_int_t mm, fortran_int_t& m, std::complex* work, + float* rwork ) { + fortran_int_t info(0); + LAPACK_CTGEVC( &lapack_option< Side >::value, &howmny, select, &n, s, + &lds, p, &ldp, vl, &ldvl, vr, &ldvr, &mm, &m, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t tgevc( const Side, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* s, const fortran_int_t lds, + const std::complex* p, const fortran_int_t ldp, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + const fortran_int_t mm, fortran_int_t& m, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTGEVC( &lapack_option< Side >::value, &howmny, select, &n, s, + &lds, p, &ldp, vl, &ldvl, vr, &ldvr, &mm, &m, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tgevc. +// +template< typename Value, typename Enable = void > +struct tgevc_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tgevc_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR, + typename WORK > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, const MatrixS& s, const MatrixP& p, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixS >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixS >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixS >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(s) )); + BOOST_ASSERT( bindings::size_column(s) >= 0 ); + BOOST_ASSERT( bindings::size_minor(p) == 1 || + bindings::stride_minor(p) == 1 ); + BOOST_ASSERT( bindings::size_minor(s) == 1 || + bindings::stride_minor(s) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(p) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(s)) ); + BOOST_ASSERT( bindings::stride_major(s) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(s)) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' ); + return detail::tgevc( side, howmny, bindings::begin_value(select), + bindings::size_column(s), bindings::begin_value(s), + bindings::stride_major(s), bindings::begin_value(p), + bindings::stride_major(p), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), mm, m, + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, const MatrixS& s, const MatrixP& p, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(s) ) ); + return invoke( side, howmny, select, s, p, vl, vr, mm, m, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, const MatrixS& s, const MatrixP& p, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, howmny, select, s, p, vl, vr, mm, m, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 6*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tgevc_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, const MatrixS& s, const MatrixP& p, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixS >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixS >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixS >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(s) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(s) )); + BOOST_ASSERT( bindings::size_column(s) >= 0 ); + BOOST_ASSERT( bindings::size_minor(p) == 1 || + bindings::stride_minor(p) == 1 ); + BOOST_ASSERT( bindings::size_minor(s) == 1 || + bindings::stride_minor(s) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(p) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(s)) ); + BOOST_ASSERT( bindings::stride_major(s) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(s)) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' ); + return detail::tgevc( side, howmny, bindings::begin_value(select), + bindings::size_column(s), bindings::begin_value(s), + bindings::stride_major(s), bindings::begin_value(p), + bindings::stride_major(p), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), mm, m, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, const MatrixS& s, const MatrixP& p, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(s) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(s) ) ); + return invoke( side, howmny, select, s, p, vl, vr, mm, m, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, const MatrixS& s, const MatrixP& p, + MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, howmny, select, s, p, vl, vr, mm, m, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tgevc_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tgevc. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgevc( const Side side, const char howmny, const VectorSELECT& select, + const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, Workspace work ) { + return tgevc_impl< typename bindings::value_type< + MatrixS >::type >::invoke( side, howmny, select, s, p, vl, vr, mm, + m, work ); +} + +// +// Overloaded function for tgevc. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixS, + typename MatrixP, typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +tgevc( const Side side, const char howmny, const VectorSELECT& select, + const MatrixS& s, const MatrixP& p, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m ) { + return tgevc_impl< typename bindings::value_type< + MatrixS >::type >::invoke( side, howmny, select, s, p, vl, vr, mm, + m, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tgexc.hpp b/sdk/boost/numeric/bindings/lapack/computational/tgexc.hpp new file mode 100644 index 0000000..8f5eeba --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tgexc.hpp @@ -0,0 +1,378 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGEXC_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGEXC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tgexc is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t tgexc( const fortran_bool_t wantq, + const fortran_bool_t wantz, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, float* q, + const fortran_int_t ldq, float* z, const fortran_int_t ldz, + fortran_int_t& ifst, fortran_int_t& ilst, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_STGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz, + &ifst, &ilst, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t tgexc( const fortran_bool_t wantq, + const fortran_bool_t wantz, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + double* q, const fortran_int_t ldq, double* z, + const fortran_int_t ldz, fortran_int_t& ifst, fortran_int_t& ilst, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DTGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz, + &ifst, &ilst, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgexc( const fortran_bool_t wantq, + const fortran_bool_t wantz, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* q, const fortran_int_t ldq, + std::complex* z, const fortran_int_t ldz, + const fortran_int_t ifst, fortran_int_t& ilst ) { + fortran_int_t info(0); + LAPACK_CTGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz, + &ifst, &ilst, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgexc( const fortran_bool_t wantq, + const fortran_bool_t wantz, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* q, const fortran_int_t ldq, + std::complex* z, const fortran_int_t ldz, + const fortran_int_t ifst, fortran_int_t& ilst ) { + fortran_int_t info(0); + LAPACK_ZTGEXC( &wantq, &wantz, &n, a, &lda, b, &ldb, q, &ldq, z, &ldz, + &ifst, &ilst, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tgexc. +// +template< typename Value, typename Enable = void > +struct tgexc_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tgexc_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const fortran_bool_t wantq, + const fortran_bool_t wantz, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::tgexc( wantq, wantz, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), ifst, + ilst, bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_bool_t wantq, + const fortran_bool_t wantz, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( wantq, wantz, a, b, q, z, ifst, ilst, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_bool_t wantq, + const fortran_bool_t wantz, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z, fortran_int_t& ifst, fortran_int_t& ilst, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::tgexc( wantq, wantz, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), ifst, + ilst, &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( wantq, wantz, a, b, q, z, ifst, ilst, + workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + if (n <= 1) + return 1; + else + return 4*n + 16; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tgexc_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_bool_t wantq, + const fortran_bool_t wantz, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z, const fortran_int_t ifst, + fortran_int_t& ilst ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::tgexc( wantq, wantz, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), ifst, + ilst ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tgexc_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tgexc. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgexc( const fortran_bool_t wantq, const fortran_bool_t wantz, + MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z, + fortran_int_t& ifst, fortran_int_t& ilst, Workspace work ) { + return tgexc_impl< typename bindings::value_type< + MatrixA >::type >::invoke( wantq, wantz, a, b, q, z, ifst, ilst, + work ); +} + +// +// Overloaded function for tgexc. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +tgexc( const fortran_bool_t wantq, const fortran_bool_t wantz, + MatrixA& a, MatrixB& b, MatrixQ& q, MatrixZ& z, + fortran_int_t& ifst, fortran_int_t& ilst ) { + return tgexc_impl< typename bindings::value_type< + MatrixA >::type >::invoke( wantq, wantz, a, b, q, z, ifst, ilst, + optimal_workspace() ); +} + +// +// Overloaded function for tgexc. Its overload differs for +// +template< typename MatrixA, typename MatrixB, typename MatrixQ, + typename MatrixZ > +inline std::ptrdiff_t tgexc( const fortran_bool_t wantq, + const fortran_bool_t wantz, MatrixA& a, MatrixB& b, MatrixQ& q, + MatrixZ& z, const fortran_int_t ifst, fortran_int_t& ilst ) { + return tgexc_impl< typename bindings::value_type< + MatrixA >::type >::invoke( wantq, wantz, a, b, q, z, ifst, ilst ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tgsen.hpp b/sdk/boost/numeric/bindings/lapack/computational/tgsen.hpp new file mode 100644 index 0000000..16d5c9a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tgsen.hpp @@ -0,0 +1,621 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSEN_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSEN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tgsen is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t tgsen( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const fortran_bool_t* select, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + float* alphar, float* alphai, float* beta, float* q, + const fortran_int_t ldq, float* z, const fortran_int_t ldz, + fortran_int_t& m, float& pl, float& pr, float* dif, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_STGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb, + alphar, alphai, beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif, work, + &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t tgsen( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const fortran_bool_t* select, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + double* alphar, double* alphai, double* beta, double* q, + const fortran_int_t ldq, double* z, const fortran_int_t ldz, + fortran_int_t& m, double& pl, double& pr, double* dif, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DTGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb, + alphar, alphai, beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif, work, + &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgsen( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const fortran_bool_t* select, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* alpha, std::complex* beta, + std::complex* q, const fortran_int_t ldq, + std::complex* z, const fortran_int_t ldz, fortran_int_t& m, + float& pl, float& pr, float* dif, std::complex* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CTGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb, alpha, + beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif, work, &lwork, iwork, + &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgsen( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const fortran_bool_t* select, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* alpha, std::complex* beta, + std::complex* q, const fortran_int_t ldq, + std::complex* z, const fortran_int_t ldz, fortran_int_t& m, + double& pl, double& pr, double* dif, std::complex* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZTGSEN( &ijob, &wantq, &wantz, select, &n, a, &lda, b, &ldb, alpha, + beta, q, &ldq, z, &ldz, &m, &pl, &pr, dif, work, &lwork, iwork, + &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tgsen. +// +template< typename Value, typename Enable = void > +struct tgsen_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tgsen_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA, + typename MatrixQ, typename MatrixZ, typename VectorDIF, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const VectorSELECT& select, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl, + real_type& pr, VectorDIF& dif, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDIF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) ); + BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(select) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( ijob, bindings::size_column(a), m )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( ijob, bindings::size_column(a), m )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::tgsen( ijob, wantq, wantz, + bindings::begin_value(select), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(z), + bindings::stride_major(z), m, pl, pr, + bindings::begin_value(dif), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA, + typename MatrixQ, typename MatrixZ, typename VectorDIF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const VectorSELECT& select, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl, + real_type& pr, VectorDIF& dif, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( ijob, + bindings::size_column(a), m ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( ijob, bindings::size_column(a), m ) ); + return invoke( ijob, wantq, wantz, select, a, b, alphar, alphai, beta, + q, z, m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA, + typename MatrixQ, typename MatrixZ, typename VectorDIF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const VectorSELECT& select, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixQ& q, MatrixZ& z, fortran_int_t& m, real_type& pl, + real_type& pr, VectorDIF& dif, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::tgsen( ijob, wantq, wantz, bindings::begin_value(select), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(alphar), + bindings::begin_value(alphai), bindings::begin_value(beta), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), m, pl, + pr, bindings::begin_value(dif), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( ijob, wantq, wantz, select, a, b, alphar, alphai, beta, + q, z, m, pl, pr, dif, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ijob, + const std::ptrdiff_t n, fortran_int_t& m ) { + if ( ijob == 1 || ijob == 2 || ijob == 4 ) + return std::max< std::ptrdiff_t >(4*n+16, 2*m*(n-m)); + else if ( ijob == 3 || ijob == 5 ) + return std::max< std::ptrdiff_t >(4*n+16, 4*m*(n-m)); + else // ijob == 0 + return std::max< std::ptrdiff_t >(1, 4*n+16); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t ijob, + const std::ptrdiff_t n, fortran_int_t& m ) { + if ( ijob == 1 || ijob == 2 || ijob == 4 ) + return std::max< std::ptrdiff_t >(1, n+6); + else if ( ijob == 3 || ijob == 5 ) + return std::max< std::ptrdiff_t >(2*m*(n-m), n+6); + else // ijob == 0 + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tgsen_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHA, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename VectorDIF, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const VectorSELECT& select, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z, + fortran_int_t& m, real_type& pl, real_type& pr, + VectorDIF& dif, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(select) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( ijob, bindings::size_column(a), m )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( ijob, bindings::size_column(a), m )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::tgsen( ijob, wantq, wantz, + bindings::begin_value(select), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(z), bindings::stride_major(z), m, pl, + pr, bindings::begin_value(dif), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHA, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename VectorDIF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const VectorSELECT& select, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z, + fortran_int_t& m, real_type& pl, real_type& pr, + VectorDIF& dif, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( ijob, + bindings::size_column(a), m ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( ijob, bindings::size_column(a), m ) ); + return invoke( ijob, wantq, wantz, select, a, b, alpha, beta, q, z, m, + pl, pr, dif, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHA, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename VectorDIF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const fortran_bool_t wantq, const fortran_bool_t wantz, + const VectorSELECT& select, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, MatrixZ& z, + fortran_int_t& m, real_type& pl, real_type& pr, + VectorDIF& dif, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::tgsen( ijob, wantq, wantz, bindings::begin_value(select), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(z), + bindings::stride_major(z), m, pl, pr, + bindings::begin_value(dif), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( ijob, wantq, wantz, select, a, b, alpha, beta, q, z, m, + pl, pr, dif, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ijob, + const std::ptrdiff_t n, fortran_int_t& m ) { + if ( ijob == 1 || ijob == 2 || ijob == 4 ) + return std::max< std::ptrdiff_t >(1, 2*m*(n-m)); + else if ( ijob == 3 || ijob == 5 ) + return std::max< std::ptrdiff_t >(1, 4*m*(n-m)); + else // ijob == 0 + return 1; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t ijob, + const std::ptrdiff_t n, fortran_int_t& m ) { + if ( ijob == 1 || ijob == 2 || ijob == 4 ) + return std::max< std::ptrdiff_t >(1, n+2); + else if ( ijob == 3 || ijob == 5 ) + return std::max< std::ptrdiff_t >(2*m*(n-m), n+2); + else // ijob == 0 + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tgsen_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tgsen. Its overload differs for +// * User-defined workspace +// +template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA, + typename MatrixQ, typename MatrixZ, typename VectorDIF, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgsen( const fortran_int_t ijob, const fortran_bool_t wantq, + const fortran_bool_t wantz, const VectorSELECT& select, MatrixA& a, + MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& pl, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& pr, + VectorDIF& dif, Workspace work ) { + return tgsen_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ijob, wantq, wantz, select, a, b, + alphar, alphai, beta, q, z, m, pl, pr, dif, work ); +} + +// +// Overloaded function for tgsen. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHAR, typename VectorALPHAI, typename VectorBETA, + typename MatrixQ, typename MatrixZ, typename VectorDIF > +inline typename boost::disable_if< detail::is_workspace< VectorDIF >, + std::ptrdiff_t >::type +tgsen( const fortran_int_t ijob, const fortran_bool_t wantq, + const fortran_bool_t wantz, const VectorSELECT& select, MatrixA& a, + MatrixB& b, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixQ& q, MatrixZ& z, fortran_int_t& m, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& pl, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& pr, + VectorDIF& dif ) { + return tgsen_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ijob, wantq, wantz, select, a, b, + alphar, alphai, beta, q, z, m, pl, pr, dif, optimal_workspace() ); +} + +// +// Overloaded function for tgsen. Its overload differs for +// * User-defined workspace +// +template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHA, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename VectorDIF, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgsen( const fortran_int_t ijob, const fortran_bool_t wantq, + const fortran_bool_t wantz, const VectorSELECT& select, MatrixA& a, + MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, + MatrixZ& z, fortran_int_t& m, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& pl, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& pr, VectorDIF& dif, Workspace work ) { + return tgsen_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ijob, wantq, wantz, select, a, b, + alpha, beta, q, z, m, pl, pr, dif, work ); +} + +// +// Overloaded function for tgsen. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename VectorALPHA, typename VectorBETA, typename MatrixQ, + typename MatrixZ, typename VectorDIF > +inline typename boost::disable_if< detail::is_workspace< VectorDIF >, + std::ptrdiff_t >::type +tgsen( const fortran_int_t ijob, const fortran_bool_t wantq, + const fortran_bool_t wantz, const VectorSELECT& select, MatrixA& a, + MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, MatrixQ& q, + MatrixZ& z, fortran_int_t& m, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& pl, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& pr, VectorDIF& dif ) { + return tgsen_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ijob, wantq, wantz, select, a, b, + alpha, beta, q, z, m, pl, pr, dif, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tgsja.hpp b/sdk/boost/numeric/bindings/lapack/computational/tgsja.hpp new file mode 100644 index 0000000..dd2d423 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tgsja.hpp @@ -0,0 +1,494 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSJA_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSJA_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tgsja is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t tgsja( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + const fortran_int_t k, const fortran_int_t l, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + const float tola, const float tolb, float* alpha, float* beta, + float* u, const fortran_int_t ldu, float* v, const fortran_int_t ldv, + float* q, const fortran_int_t ldq, float* work, + fortran_int_t& ncycle ) { + fortran_int_t info(0); + LAPACK_STGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b, &ldb, + &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, + &ncycle, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t tgsja( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + const fortran_int_t k, const fortran_int_t l, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + const double tola, const double tolb, double* alpha, double* beta, + double* u, const fortran_int_t ldu, double* v, + const fortran_int_t ldv, double* q, const fortran_int_t ldq, + double* work, fortran_int_t& ncycle ) { + fortran_int_t info(0); + LAPACK_DTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b, &ldb, + &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, + &ncycle, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgsja( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + const fortran_int_t k, const fortran_int_t l, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, const float tola, const float tolb, + float* alpha, float* beta, std::complex* u, + const fortran_int_t ldu, std::complex* v, + const fortran_int_t ldv, std::complex* q, + const fortran_int_t ldq, std::complex* work, + fortran_int_t& ncycle ) { + fortran_int_t info(0); + LAPACK_CTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b, &ldb, + &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, + &ncycle, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgsja( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t p, const fortran_int_t n, + const fortran_int_t k, const fortran_int_t l, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, const double tola, const double tolb, + double* alpha, double* beta, std::complex* u, + const fortran_int_t ldu, std::complex* v, + const fortran_int_t ldv, std::complex* q, + const fortran_int_t ldq, std::complex* work, + fortran_int_t& ncycle ) { + fortran_int_t info(0); + LAPACK_ZTGSJA( &jobu, &jobv, &jobq, &m, &p, &n, &k, &l, a, &lda, b, &ldb, + &tola, &tolb, alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, + &ncycle, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tgsja. +// +template< typename Value, typename Enable = void > +struct tgsja_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tgsja_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ, typename WORK > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, const fortran_int_t k, + const fortran_int_t l, MatrixA& a, MatrixB& b, + const real_type tola, const real_type tolb, VectorALPHA& alpha, + VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q, + fortran_int_t& ncycle, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + BOOST_ASSERT( jobq == 'Q' || jobq == 'I' || jobq == 'N' ); + BOOST_ASSERT( jobu == 'U' || jobu == 'I' || jobu == 'N' ); + BOOST_ASSERT( jobv == 'V' || jobv == 'I' || jobv == 'N' ); + return detail::tgsja( jobu, jobv, jobq, bindings::size_row(a), + bindings::size_row(b), bindings::size_column(a), k, l, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), tola, + tolb, bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(u), + bindings::stride_major(u), bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(real_type())), ncycle ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, const fortran_int_t k, + const fortran_int_t l, MatrixA& a, MatrixB& b, + const real_type tola, const real_type tolb, VectorALPHA& alpha, + VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q, + fortran_int_t& ncycle, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, + u, v, q, ncycle, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, const fortran_int_t k, + const fortran_int_t l, MatrixA& a, MatrixB& b, + const real_type tola, const real_type tolb, VectorALPHA& alpha, + VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q, + fortran_int_t& ncycle, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, + u, v, q, ncycle, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tgsja_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ, typename WORK > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, const fortran_int_t k, + const fortran_int_t l, MatrixA& a, MatrixB& b, + const real_type tola, const real_type tolb, VectorALPHA& alpha, + VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q, + fortran_int_t& ncycle, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorALPHA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + BOOST_ASSERT( jobq == 'Q' || jobq == 'I' || jobq == 'N' ); + BOOST_ASSERT( jobu == 'U' || jobu == 'I' || jobu == 'N' ); + BOOST_ASSERT( jobv == 'V' || jobv == 'I' || jobv == 'N' ); + return detail::tgsja( jobu, jobv, jobq, bindings::size_row(a), + bindings::size_row(b), bindings::size_column(a), k, l, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), tola, + tolb, bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(u), + bindings::stride_major(u), bindings::begin_value(v), + bindings::stride_major(v), bindings::begin_value(q), + bindings::stride_major(q), + bindings::begin_value(work.select(value_type())), ncycle ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, const fortran_int_t k, + const fortran_int_t l, MatrixA& a, MatrixB& b, + const real_type tola, const real_type tolb, VectorALPHA& alpha, + VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q, + fortran_int_t& ncycle, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, + u, v, q, ncycle, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, const fortran_int_t k, + const fortran_int_t l, MatrixA& a, MatrixB& b, + const real_type tola, const real_type tolb, VectorALPHA& alpha, + VectorBETA& beta, MatrixU& u, MatrixV& v, MatrixQ& q, + fortran_int_t& ncycle, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobu, jobv, jobq, k, l, a, b, tola, tolb, alpha, beta, + u, v, q, ncycle, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tgsja_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tgsja. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgsja( const char jobu, const char jobv, const char jobq, + const fortran_int_t k, const fortran_int_t l, MatrixA& a, + MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type tola, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type tolb, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, fortran_int_t& ncycle, + Workspace work ) { + return tgsja_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobv, jobq, k, l, a, b, tola, + tolb, alpha, beta, u, v, q, ncycle, work ); +} + +// +// Overloaded function for tgsja. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +tgsja( const char jobu, const char jobv, const char jobq, + const fortran_int_t k, const fortran_int_t l, MatrixA& a, + MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type tola, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type tolb, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, fortran_int_t& ncycle ) { + return tgsja_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobv, jobq, k, l, a, b, tola, + tolb, alpha, beta, u, v, q, ncycle, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tgsna.hpp b/sdk/boost/numeric/bindings/lapack/computational/tgsna.hpp new file mode 100644 index 0000000..8ad6de1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tgsna.hpp @@ -0,0 +1,498 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSNA_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSNA_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tgsna is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t tgsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, const float* a, + const fortran_int_t lda, const float* b, const fortran_int_t ldb, + const float* vl, const fortran_int_t ldvl, const float* vr, + const fortran_int_t ldvr, float* s, float* dif, + const fortran_int_t mm, fortran_int_t& m, float* work, + const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl, vr, + &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t tgsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, const double* a, + const fortran_int_t lda, const double* b, const fortran_int_t ldb, + const double* vl, const fortran_int_t ldvl, const double* vr, + const fortran_int_t ldvr, double* s, double* dif, + const fortran_int_t mm, fortran_int_t& m, double* work, + const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl, vr, + &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex* vl, const fortran_int_t ldvl, + const std::complex* vr, const fortran_int_t ldvr, float* s, + float* dif, const fortran_int_t mm, fortran_int_t& m, + std::complex* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_CTGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl, vr, + &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tgsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex* vl, const fortran_int_t ldvl, + const std::complex* vr, const fortran_int_t ldvr, double* s, + double* dif, const fortran_int_t mm, fortran_int_t& m, + std::complex* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_ZTGSNA( &job, &howmny, select, &n, a, &lda, b, &ldb, vl, &ldvl, vr, + &ldvr, s, dif, &mm, &m, work, &lwork, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tgsna. +// +template< typename Value, typename Enable = void > +struct tgsna_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tgsna_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const fortran_int_t n, + const MatrixA& a, const MatrixB& b, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDIF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( job, n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( job, n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'S' ); + BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' ); + BOOST_ASSERT( n >= 0 ); + return detail::tgsna( job, howmny, bindings::begin_value(select), n, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + bindings::begin_value(s), bindings::begin_value(dif), mm, m, + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const fortran_int_t n, + const MatrixA& a, const MatrixB& b, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( job, + n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( job, n ) ); + return invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const fortran_int_t n, + const MatrixA& a, const MatrixB& b, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( job, n ) ); + detail::tgsna( job, howmny, bindings::begin_value(select), n, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + bindings::begin_value(s), bindings::begin_value(dif), mm, m, + &opt_size_work, -1, bindings::begin_value(tmp_iwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, + const std::ptrdiff_t n ) { + if ( job == 'V' || job == 'B' ) + return std::max< std::ptrdiff_t >(1, 2*n*(n+2)+16); + else + return std::max< std::ptrdiff_t >(1, n); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char job, + const std::ptrdiff_t n ) { + if ( job == 'E') + return 1; + else + return n+6; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tgsna_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const fortran_int_t n, + const MatrixA& a, const MatrixB& b, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDIF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDIF >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( job, n )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( job, n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'S' ); + BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' ); + BOOST_ASSERT( n >= 0 ); + return detail::tgsna( job, howmny, bindings::begin_value(select), n, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + bindings::begin_value(s), bindings::begin_value(dif), mm, m, + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const fortran_int_t n, + const MatrixA& a, const MatrixB& b, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( job, + n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( job, n ) ); + return invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const fortran_int_t n, + const MatrixA& a, const MatrixB& b, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( job, howmny, select, n, a, b, vl, vr, s, dif, mm, m, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, + const std::ptrdiff_t n ) { + if ( job == 'V' || job == 'B' ) + return std::max< std::ptrdiff_t >(1, 2*n*n); + else + return std::max< std::ptrdiff_t >(1, n); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char job, + const std::ptrdiff_t n ) { + if ( job == 'E') + return 1; + else + return n+2; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tgsna_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tgsna. Its overload differs for +// * User-defined workspace +// +template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgsna( const char job, const char howmny, const VectorSELECT& select, + const fortran_int_t n, const MatrixA& a, const MatrixB& b, + const MatrixVL& vl, const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m, Workspace work ) { + return tgsna_impl< typename bindings::value_type< + MatrixA >::type >::invoke( job, howmny, select, n, a, b, vl, vr, + s, dif, mm, m, work ); +} + +// +// Overloaded function for tgsna. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorSELECT, typename MatrixA, typename MatrixB, + typename MatrixVL, typename MatrixVR, typename VectorS, + typename VectorDIF > +inline typename boost::disable_if< detail::is_workspace< VectorDIF >, + std::ptrdiff_t >::type +tgsna( const char job, const char howmny, const VectorSELECT& select, + const fortran_int_t n, const MatrixA& a, const MatrixB& b, + const MatrixVL& vl, const MatrixVR& vr, VectorS& s, VectorDIF& dif, + const fortran_int_t mm, fortran_int_t& m ) { + return tgsna_impl< typename bindings::value_type< + MatrixA >::type >::invoke( job, howmny, select, n, a, b, vl, vr, + s, dif, mm, m, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tgsyl.hpp b/sdk/boost/numeric/bindings/lapack/computational/tgsyl.hpp new file mode 100644 index 0000000..dc338e0 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tgsyl.hpp @@ -0,0 +1,548 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSYL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TGSYL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tgsyl is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t tgsyl( const Trans, const fortran_int_t ijob, + const fortran_int_t m, const fortran_int_t n, const float* a, + const fortran_int_t lda, const float* b, const fortran_int_t ldb, + float* c, const fortran_int_t ldc, const float* d, + const fortran_int_t ldd, const float* e, const fortran_int_t lde, + float* f, const fortran_int_t ldf, float& scale, float& dif, + float* work, const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STGSYL( &lapack_option< Trans >::value, &ijob, &m, &n, a, &lda, b, + &ldb, c, &ldc, d, &ldd, e, &lde, f, &ldf, &scale, &dif, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t tgsyl( const Trans, const fortran_int_t ijob, + const fortran_int_t m, const fortran_int_t n, const double* a, + const fortran_int_t lda, const double* b, const fortran_int_t ldb, + double* c, const fortran_int_t ldc, const double* d, + const fortran_int_t ldd, const double* e, const fortran_int_t lde, + double* f, const fortran_int_t ldf, double& scale, double& dif, + double* work, const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTGSYL( &lapack_option< Trans >::value, &ijob, &m, &n, a, &lda, b, + &ldb, c, &ldc, d, &ldd, e, &lde, f, &ldf, &scale, &dif, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t tgsyl( const Trans, const fortran_int_t ijob, + const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + std::complex* c, const fortran_int_t ldc, + const std::complex* d, const fortran_int_t ldd, + const std::complex* e, const fortran_int_t lde, + std::complex* f, const fortran_int_t ldf, float& scale, + float& dif, std::complex* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_CTGSYL( &lapack_option< Trans >::value, &ijob, &m, &n, a, &lda, b, + &ldb, c, &ldc, d, &ldd, e, &lde, f, &ldf, &scale, &dif, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t tgsyl( const Trans, const fortran_int_t ijob, + const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + std::complex* c, const fortran_int_t ldc, + const std::complex* d, const fortran_int_t ldd, + const std::complex* e, const fortran_int_t lde, + std::complex* f, const fortran_int_t ldf, double& scale, + double& dif, std::complex* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_ZTGSYL( &lapack_option< Trans >::value, &ijob, &m, &n, a, &lda, b, + &ldb, c, &ldc, d, &ldd, e, &lde, f, &ldf, &scale, &dif, work, + &lwork, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tgsyl. +// +template< typename Value, typename Enable = void > +struct tgsyl_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tgsyl_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d, + const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixF >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixF >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(a, trans()), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(a, trans()), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(d) == 1 || + bindings::stride_minor(d) == 1 ); + BOOST_ASSERT( bindings::size_minor(e) == 1 || + bindings::stride_minor(e) == 1 ); + BOOST_ASSERT( bindings::size_minor(f) == 1 || + bindings::stride_minor(f) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(b)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(d) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(e) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(b)) ); + BOOST_ASSERT( bindings::stride_major(f) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::tgsyl( trans(), ijob, bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::stride_major(c), bindings::begin_value(d), + bindings::stride_major(d), bindings::begin_value(e), + bindings::stride_major(e), bindings::begin_value(f), + bindings::stride_major(f), scale, dif, + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d, + const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()), + bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()), + bindings::size_column(b) ) ); + return invoke( ijob, a, b, c, d, e, f, scale, dif, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d, + const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()), + bindings::size_column(b) ) ); + detail::tgsyl( trans(), ijob, bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::stride_major(c), bindings::begin_value(d), + bindings::stride_major(d), bindings::begin_value(e), + bindings::stride_major(e), bindings::begin_value(f), + bindings::stride_major(f), scale, dif, &opt_size_work, -1, + bindings::begin_value(tmp_iwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( ijob, a, b, c, d, e, f, scale, dif, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*m*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return m+n+6; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tgsyl_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d, + const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixF >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixF >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(a, trans()), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(a, trans()), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_minor(d) == 1 || + bindings::stride_minor(d) == 1 ); + BOOST_ASSERT( bindings::size_minor(e) == 1 || + bindings::stride_minor(e) == 1 ); + BOOST_ASSERT( bindings::size_minor(f) == 1 || + bindings::stride_minor(f) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(b)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(d) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(e) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(b)) ); + BOOST_ASSERT( bindings::stride_major(f) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::tgsyl( trans(), ijob, bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::stride_major(c), bindings::begin_value(d), + bindings::stride_major(d), bindings::begin_value(e), + bindings::stride_major(e), bindings::begin_value(f), + bindings::stride_major(f), scale, dif, + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d, + const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()), + bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()), + bindings::size_column(b) ) ); + return invoke( ijob, a, b, c, d, e, f, scale, dif, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF > + static std::ptrdiff_t invoke( const fortran_int_t ijob, + const MatrixA& a, const MatrixB& b, MatrixC& c, const MatrixD& d, + const MatrixE& e, MatrixF& f, real_type& scale, real_type& dif, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()), + bindings::size_column(b) ) ); + detail::tgsyl( trans(), ijob, bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::stride_major(c), bindings::begin_value(d), + bindings::stride_major(d), bindings::begin_value(e), + bindings::stride_major(e), bindings::begin_value(f), + bindings::stride_major(f), scale, dif, &opt_size_work, -1, + bindings::begin_value(tmp_iwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( ijob, a, b, c, d, e, f, scale, dif, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*m*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return m+n+2; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tgsyl_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tgsyl. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tgsyl( const fortran_int_t ijob, const MatrixA& a, const MatrixB& b, + MatrixC& c, const MatrixD& d, const MatrixE& e, MatrixF& f, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& scale, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& dif, + Workspace work ) { + return tgsyl_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ijob, a, b, c, d, e, f, scale, dif, + work ); +} + +// +// Overloaded function for tgsyl. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename MatrixC, + typename MatrixD, typename MatrixE, typename MatrixF > +inline typename boost::disable_if< detail::is_workspace< MatrixF >, + std::ptrdiff_t >::type +tgsyl( const fortran_int_t ijob, const MatrixA& a, const MatrixB& b, + MatrixC& c, const MatrixD& d, const MatrixE& e, MatrixF& f, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& scale, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& dif ) { + return tgsyl_impl< typename bindings::value_type< + MatrixA >::type >::invoke( ijob, a, b, c, d, e, f, scale, dif, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tpcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/tpcon.hpp new file mode 100644 index 0000000..693c58f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tpcon.hpp @@ -0,0 +1,333 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tpcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tpcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const float* ap, float& rcond, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STPCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tpcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const double* ap, double& rcond, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTPCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tpcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const std::complex* ap, float& rcond, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CTPCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &rcond, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tpcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const std::complex* ap, double& rcond, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTPCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &rcond, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tpcon. +// +template< typename Value, typename Enable = void > +struct tpcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tpcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + real_type& rcond, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::tpcon( norm, uplo(), diag(), bindings::size_column(ap), + bindings::begin_value(ap), rcond, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( norm, ap, rcond, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + return invoke( norm, ap, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tpcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + real_type& rcond, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::tpcon( norm, uplo(), diag(), bindings::size_column(ap), + bindings::begin_value(ap), rcond, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( norm, ap, rcond, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( const char norm, const MatrixAP& ap, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + return invoke( norm, ap, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tpcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tpcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tpcon( const char norm, const MatrixAP& ap, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond, + Workspace work ) { + return tpcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, ap, rcond, work ); +} + +// +// Overloaded function for tpcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP > +inline typename boost::disable_if< detail::is_workspace< MatrixAP >, + std::ptrdiff_t >::type +tpcon( const char norm, const MatrixAP& ap, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond ) { + return tpcon_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( norm, ap, rcond, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tprfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/tprfs.hpp new file mode 100644 index 0000000..95b8d67 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tprfs.hpp @@ -0,0 +1,440 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tprfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tprfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const float* ap, + const float* b, const fortran_int_t ldb, const float* x, + const fortran_int_t ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STPRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tprfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const double* ap, + const double* b, const fortran_int_t ldb, const double* x, + const fortran_int_t ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTPRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tprfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, const std::complex* b, + const fortran_int_t ldb, const std::complex* x, + const fortran_int_t ldx, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CTPRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tprfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, const std::complex* b, + const fortran_int_t ldb, const std::complex* x, + const fortran_int_t ldx, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTPRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tprfs. +// +template< typename Value, typename Enable = void > +struct tprfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tprfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(ap, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(ap, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ap, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ap, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ap, trans())) ); + return detail::tprfs( uplo(), trans(), diag(), + bindings::size_column_op(ap, trans()), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(ap, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(ap, trans()) ) ); + return invoke( ap, b, x, ferr, berr, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + return invoke( ap, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tprfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(ap, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(ap, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ap, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ap, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ap, trans())) ); + return detail::tprfs( uplo(), trans(), diag(), + bindings::size_column_op(ap, trans()), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(ap, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(ap, trans()) ) ); + return invoke( ap, b, x, ferr, berr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixAP& ap, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + return invoke( ap, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tprfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tprfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tprfs( const MatrixAP& ap, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return tprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, b, x, ferr, berr, work ); +} + +// +// Overloaded function for tprfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +tprfs( const MatrixAP& ap, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr ) { + return tprfs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tptri.hpp b/sdk/boost/numeric/bindings/lapack/computational/tptri.hpp new file mode 100644 index 0000000..4fa7f2f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tptri.hpp @@ -0,0 +1,157 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tptri is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tptri( const UpLo, const Diag, const fortran_int_t n, + float* ap ) { + fortran_int_t info(0); + LAPACK_STPTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tptri( const UpLo, const Diag, const fortran_int_t n, + double* ap ) { + fortran_int_t info(0); + LAPACK_DTPTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tptri( const UpLo, const Diag, const fortran_int_t n, + std::complex* ap ) { + fortran_int_t info(0); + LAPACK_CTPTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t tptri( const UpLo, const Diag, const fortran_int_t n, + std::complex* ap ) { + fortran_int_t info(0); + LAPACK_ZTPTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, ap, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tptri. +// +template< typename Value > +struct tptri_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP > + static std::ptrdiff_t invoke( MatrixAP& ap ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + return detail::tptri( uplo(), diag(), bindings::size_column(ap), + bindings::begin_value(ap) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tptri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tptri. Its overload differs for +// +template< typename MatrixAP > +inline std::ptrdiff_t tptri( MatrixAP& ap ) { + return tptri_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tptrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/tptrs.hpp new file mode 100644 index 0000000..b0df245 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tptrs.hpp @@ -0,0 +1,182 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TPTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tptrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tptrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const float* ap, + float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_STPTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tptrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const double* ap, + double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DTPTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tptrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CTPTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t tptrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZTPTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, ap, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tptrs. +// +template< typename Value > +struct tptrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixAP& ap, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixAP, order >::type trans; + typedef typename result_of::uplo_tag< MatrixAP, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixAP >::type diag; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ap, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ap, trans())) ); + return detail::tptrs( uplo(), trans(), diag(), + bindings::size_column_op(ap, trans()), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tptrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tptrs. Its overload differs for +// +template< typename MatrixAP, typename MatrixB > +inline std::ptrdiff_t tptrs( const MatrixAP& ap, MatrixB& b ) { + return tptrs_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trcon.hpp b/sdk/boost/numeric/bindings/lapack/computational/trcon.hpp new file mode 100644 index 0000000..4a72885 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trcon.hpp @@ -0,0 +1,346 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRCON_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRCON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trcon is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t trcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const float* a, const fortran_int_t lda, + float& rcond, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STRCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t trcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const double* a, const fortran_int_t lda, + double& rcond, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTRCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &rcond, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t trcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, float& rcond, std::complex* work, + float* rwork ) { + fortran_int_t info(0); + LAPACK_CTRCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &rcond, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Diag > +inline std::ptrdiff_t trcon( const char norm, const UpLo, const Diag, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, double& rcond, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTRCON( &norm, &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &rcond, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trcon. +// +template< typename Value, typename Enable = void > +struct trcon_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct trcon_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + real_type& rcond, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::trcon( norm, uplo(), diag(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), rcond, + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( norm, a, rcond, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + return invoke( norm, a, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct trcon_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + real_type& rcond, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( norm == '1' || norm == 'O' || norm == 'I' ); + return detail::trcon( norm, uplo(), diag(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), rcond, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + real_type& rcond, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( norm, a, rcond, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA > + static std::ptrdiff_t invoke( const char norm, const MatrixA& a, + real_type& rcond, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + return invoke( norm, a, rcond, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trcon_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trcon. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trcon( const char norm, const MatrixA& a, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + Workspace work ) { + return trcon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, rcond, work ); +} + +// +// Overloaded function for trcon. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA > +inline typename boost::disable_if< detail::is_workspace< MatrixA >, + std::ptrdiff_t >::type +trcon( const char norm, const MatrixA& a, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond ) { + return trcon_impl< typename bindings::value_type< + MatrixA >::type >::invoke( norm, a, rcond, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trevc.hpp b/sdk/boost/numeric/bindings/lapack/computational/trevc.hpp new file mode 100644 index 0000000..79452e9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trevc.hpp @@ -0,0 +1,509 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TREVC_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TREVC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trevc is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side > +inline std::ptrdiff_t trevc( const Side, const char howmny, + fortran_bool_t* select, const fortran_int_t n, const float* t, + const fortran_int_t ldt, float* vl, const fortran_int_t ldvl, + float* vr, const fortran_int_t ldvr, const fortran_int_t mm, + fortran_int_t& m, float* work ) { + fortran_int_t info(0); + LAPACK_STREVC( &lapack_option< Side >::value, &howmny, select, &n, t, + &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side > +inline std::ptrdiff_t trevc( const Side, const char howmny, + fortran_bool_t* select, const fortran_int_t n, const double* t, + const fortran_int_t ldt, double* vl, const fortran_int_t ldvl, + double* vr, const fortran_int_t ldvr, const fortran_int_t mm, + fortran_int_t& m, double* work ) { + fortran_int_t info(0); + LAPACK_DTREVC( &lapack_option< Side >::value, &howmny, select, &n, t, + &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t trevc( const Side, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + std::complex* t, const fortran_int_t ldt, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + const fortran_int_t mm, fortran_int_t& m, std::complex* work, + float* rwork ) { + fortran_int_t info(0); + LAPACK_CTREVC( &lapack_option< Side >::value, &howmny, select, &n, t, + &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side > +inline std::ptrdiff_t trevc( const Side, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + std::complex* t, const fortran_int_t ldt, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + const fortran_int_t mm, fortran_int_t& m, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTREVC( &lapack_option< Side >::value, &howmny, select, &n, t, + &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trevc. +// +template< typename Value, typename Enable = void > +struct trevc_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct trevc_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR, typename WORK > + static std::ptrdiff_t invoke( const Side side, const char howmny, + VectorSELECT& select, const MatrixT& t, MatrixVL& vl, + MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSELECT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' ); + return detail::trevc( side, howmny, bindings::begin_value(select), + bindings::size_column(t), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), mm, m, + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + VectorSELECT& select, const MatrixT& t, MatrixVL& vl, + MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(t) ) ); + return invoke( side, howmny, select, t, vl, vr, mm, m, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + VectorSELECT& select, const MatrixT& t, MatrixVL& vl, + MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, howmny, select, t, vl, vr, mm, m, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct trevc_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, MatrixT& t, MatrixVL& vl, + MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(t) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'B' || howmny == 'S' ); + return detail::trevc( side, howmny, bindings::begin_value(select), + bindings::size_column(t), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), mm, m, + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, MatrixT& t, MatrixVL& vl, + MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(t) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(t) ) ); + return invoke( side, howmny, select, t, vl, vr, mm, m, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const Side side, const char howmny, + const VectorSELECT& select, MatrixT& t, MatrixVL& vl, + MatrixVR& vr, const fortran_int_t mm, fortran_int_t& m, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( side, howmny, select, t, vl, vr, mm, m, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trevc_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trevc. Its overload differs for +// * VectorSELECT& +// * MatrixT& +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, VectorSELECT& select, + MatrixT& t, MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, Workspace work ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + work ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * VectorSELECT& +// * MatrixT& +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, VectorSELECT& select, + MatrixT& t, MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + optimal_workspace() ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * const VectorSELECT& +// * MatrixT& +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, const VectorSELECT& select, + MatrixT& t, MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m, Workspace work ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + work ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * const VectorSELECT& +// * MatrixT& +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, const VectorSELECT& select, + MatrixT& t, MatrixVL& vl, MatrixVR& vr, const fortran_int_t mm, + fortran_int_t& m ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + optimal_workspace() ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * VectorSELECT& +// * const MatrixT& +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, VectorSELECT& select, + const MatrixT& t, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, Workspace work ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + work ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * VectorSELECT& +// * const MatrixT& +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, VectorSELECT& select, + const MatrixT& t, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + optimal_workspace() ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * const VectorSELECT& +// * const MatrixT& +// * User-defined workspace +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, const VectorSELECT& select, + const MatrixT& t, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m, Workspace work ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + work ); +} + +// +// Overloaded function for trevc. Its overload differs for +// * const VectorSELECT& +// * const MatrixT& +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorSELECT, typename MatrixT, + typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +trevc( const Side side, const char howmny, const VectorSELECT& select, + const MatrixT& t, MatrixVL& vl, MatrixVR& vr, + const fortran_int_t mm, fortran_int_t& m ) { + return trevc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( side, howmny, select, t, vl, vr, mm, m, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trexc.hpp b/sdk/boost/numeric/bindings/lapack/computational/trexc.hpp new file mode 100644 index 0000000..1c3655e --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trexc.hpp @@ -0,0 +1,297 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TREXC_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TREXC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trexc is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t trexc( const char compq, const fortran_int_t n, float* t, + const fortran_int_t ldt, float* q, const fortran_int_t ldq, + fortran_int_t& ifst, fortran_int_t& ilst, float* work ) { + fortran_int_t info(0); + LAPACK_STREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t trexc( const char compq, const fortran_int_t n, + double* t, const fortran_int_t ldt, double* q, + const fortran_int_t ldq, fortran_int_t& ifst, fortran_int_t& ilst, + double* work ) { + fortran_int_t info(0); + LAPACK_DTREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trexc( const char compq, const fortran_int_t n, + std::complex* t, const fortran_int_t ldt, + std::complex* q, const fortran_int_t ldq, + const fortran_int_t ifst, const fortran_int_t ilst ) { + fortran_int_t info(0); + LAPACK_CTREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trexc( const char compq, const fortran_int_t n, + std::complex* t, const fortran_int_t ldt, + std::complex* q, const fortran_int_t ldq, + const fortran_int_t ifst, const fortran_int_t ilst ) { + fortran_int_t info(0); + LAPACK_ZTREXC( &compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trexc. +// +template< typename Value, typename Enable = void > +struct trexc_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct trexc_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixT, typename MatrixQ, typename WORK > + static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q, + fortran_int_t& ifst, fortran_int_t& ilst, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( compq == 'V' || compq == 'N' ); + return detail::trexc( compq, bindings::size_column(t), + bindings::begin_value(t), bindings::stride_major(t), + bindings::begin_value(q), bindings::stride_major(q), ifst, + ilst, bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixT, typename MatrixQ > + static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q, + fortran_int_t& ifst, fortran_int_t& ilst, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(t) ) ); + return invoke( compq, t, q, ifst, ilst, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixT, typename MatrixQ > + static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q, + fortran_int_t& ifst, fortran_int_t& ilst, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( compq, t, q, ifst, ilst, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct trexc_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixT, typename MatrixQ > + static std::ptrdiff_t invoke( const char compq, MatrixT& t, MatrixQ& q, + const fortran_int_t ifst, const fortran_int_t ilst ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( compq == 'V' || compq == 'N' ); + return detail::trexc( compq, bindings::size_column(t), + bindings::begin_value(t), bindings::stride_major(t), + bindings::begin_value(q), bindings::stride_major(q), ifst, + ilst ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trexc_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trexc. Its overload differs for +// * User-defined workspace +// +template< typename MatrixT, typename MatrixQ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trexc( const char compq, MatrixT& t, MatrixQ& q, fortran_int_t& ifst, + fortran_int_t& ilst, Workspace work ) { + return trexc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( compq, t, q, ifst, ilst, work ); +} + +// +// Overloaded function for trexc. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixT, typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +trexc( const char compq, MatrixT& t, MatrixQ& q, fortran_int_t& ifst, + fortran_int_t& ilst ) { + return trexc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( compq, t, q, ifst, ilst, + optimal_workspace() ); +} + +// +// Overloaded function for trexc. Its overload differs for +// +template< typename MatrixT, typename MatrixQ > +inline std::ptrdiff_t trexc( const char compq, MatrixT& t, MatrixQ& q, + const fortran_int_t ifst, const fortran_int_t ilst ) { + return trexc_impl< typename bindings::value_type< + MatrixT >::type >::invoke( compq, t, q, ifst, ilst ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trrfs.hpp b/sdk/boost/numeric/bindings/lapack/computational/trrfs.hpp new file mode 100644 index 0000000..eb5f586 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trrfs.hpp @@ -0,0 +1,448 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRRFS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRRFS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trrfs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const float* a, + const fortran_int_t lda, const float* b, const fortran_int_t ldb, + const float* x, const fortran_int_t ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STRRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const double* a, + const fortran_int_t lda, const double* b, const fortran_int_t ldb, + const double* x, const fortran_int_t ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTRRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, x, &ldx, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex* x, const fortran_int_t ldx, float* ferr, + float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CTRRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trrfs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + const std::complex* b, const fortran_int_t ldb, + const std::complex* x, const fortran_int_t ldx, double* ferr, + double* berr, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTRRFS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, x, &ldx, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trrfs. +// +template< typename Value, typename Enable = void > +struct trrfs_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct trrfs_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::trrfs( uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()) ) ); + return invoke( a, b, x, ferr, berr, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + return invoke( a, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct trrfs_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::trrfs( uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(a, trans()) ) ); + return invoke( a, b, x, ferr, berr, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const MatrixA& a, const MatrixB& b, + const MatrixX& x, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + return invoke( a, b, x, ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trrfs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trrfs. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trrfs( const MatrixA& a, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return trrfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, x, ferr, berr, work ); +} + +// +// Overloaded function for trrfs. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +trrfs( const MatrixA& a, const MatrixB& b, const MatrixX& x, + VectorFERR& ferr, VectorBERR& berr ) { + return trrfs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, x, ferr, berr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trsen.hpp b/sdk/boost/numeric/bindings/lapack/computational/trsen.hpp new file mode 100644 index 0000000..6ee54a9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trsen.hpp @@ -0,0 +1,254 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSEN_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSEN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trsen is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trsen( const char job, const char compq, + const fortran_bool_t* select, const fortran_int_t n, + std::complex* t, const fortran_int_t ldt, + std::complex* q, const fortran_int_t ldq, + std::complex* w, fortran_int_t& m, float& s, float& sep, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CTRSEN( &job, &compq, select, &n, t, &ldt, q, &ldq, w, &m, &s, + &sep, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trsen( const char job, const char compq, + const fortran_bool_t* select, const fortran_int_t n, + std::complex* t, const fortran_int_t ldt, + std::complex* q, const fortran_int_t ldq, + std::complex* w, fortran_int_t& m, double& s, double& sep, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZTRSEN( &job, &compq, select, &n, t, &ldt, q, &ldq, w, &m, &s, + &sep, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trsen. +// +template< typename Value > +struct trsen_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixT, typename MatrixQ, + typename VectorW, typename WORK > + static std::ptrdiff_t invoke( const char job, const char compq, + const VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w, + fortran_int_t& m, real_type& s, real_type& sep, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(select) >= bindings::size_column(t) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(t) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( job, bindings::size_column(t), m )); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( compq == 'V' || compq == 'N' ); + BOOST_ASSERT( job == 'N' || job == 'E' || job == 'V' || job == 'B' ); + return detail::trsen( job, compq, bindings::begin_value(select), + bindings::size_column(t), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(w), m, s, + sep, bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixT, typename MatrixQ, + typename VectorW > + static std::ptrdiff_t invoke( const char job, const char compq, + const VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w, + fortran_int_t& m, real_type& s, real_type& sep, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( job, + bindings::size_column(t), m ) ); + return invoke( job, compq, select, t, q, w, m, s, sep, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixT, typename MatrixQ, + typename VectorW > + static std::ptrdiff_t invoke( const char job, const char compq, + const VectorSELECT& select, MatrixT& t, MatrixQ& q, VectorW& w, + fortran_int_t& m, real_type& s, real_type& sep, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::trsen( job, compq, bindings::begin_value(select), + bindings::size_column(t), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(q), + bindings::stride_major(q), bindings::begin_value(w), m, s, + sep, &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( job, compq, select, t, q, w, m, s, sep, + workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, const std::ptrdiff_t n, + fortran_int_t& m ) { + if ( job == 'N' ) + return 1; + else if ( job == 'E' ) + return std::max< std::ptrdiff_t >(1, m*(n-m)); + else // if ( job == 'V' || job == 'B' ) + return std::max< std::ptrdiff_t >(1, 2*m*(n-m)); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trsen_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trsen. Its overload differs for +// * User-defined workspace +// +template< typename VectorSELECT, typename MatrixT, typename MatrixQ, + typename VectorW, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trsen( const char job, const char compq, const VectorSELECT& select, + MatrixT& t, MatrixQ& q, VectorW& w, fortran_int_t& m, + typename remove_imaginary< typename bindings::value_type< + VectorSELECT >::type >::type& s, typename remove_imaginary< + typename bindings::value_type< VectorSELECT >::type >::type& sep, + Workspace work ) { + return trsen_impl< typename bindings::value_type< + VectorSELECT >::type >::invoke( job, compq, select, t, q, w, m, s, + sep, work ); +} + +// +// Overloaded function for trsen. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorSELECT, typename MatrixT, typename MatrixQ, + typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +trsen( const char job, const char compq, const VectorSELECT& select, + MatrixT& t, MatrixQ& q, VectorW& w, fortran_int_t& m, + typename remove_imaginary< typename bindings::value_type< + VectorSELECT >::type >::type& s, typename remove_imaginary< + typename bindings::value_type< VectorSELECT >::type >::type& sep ) { + return trsen_impl< typename bindings::value_type< + VectorSELECT >::type >::invoke( job, compq, select, t, q, w, m, s, + sep, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trsna.hpp b/sdk/boost/numeric/bindings/lapack/computational/trsna.hpp new file mode 100644 index 0000000..f57a044 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trsna.hpp @@ -0,0 +1,439 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSNA_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSNA_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trsna is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t trsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, const float* t, + const fortran_int_t ldt, const float* vl, const fortran_int_t ldvl, + const float* vr, const fortran_int_t ldvr, float* s, float* sep, + const fortran_int_t mm, fortran_int_t& m, float* work, + const fortran_int_t ldwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_STRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, + s, sep, &mm, &m, work, &ldwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t trsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, const double* t, + const fortran_int_t ldt, const double* vl, const fortran_int_t ldvl, + const double* vr, const fortran_int_t ldvr, double* s, double* sep, + const fortran_int_t mm, fortran_int_t& m, double* work, + const fortran_int_t ldwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DTRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, + s, sep, &mm, &m, work, &ldwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* t, const fortran_int_t ldt, + const std::complex* vl, const fortran_int_t ldvl, + const std::complex* vr, const fortran_int_t ldvr, float* s, + float* sep, const fortran_int_t mm, fortran_int_t& m, + std::complex* work, const fortran_int_t ldwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CTRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, + s, sep, &mm, &m, work, &ldwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trsna( const char job, const char howmny, + const fortran_bool_t* select, const fortran_int_t n, + const std::complex* t, const fortran_int_t ldt, + const std::complex* vl, const fortran_int_t ldvl, + const std::complex* vr, const fortran_int_t ldvr, double* s, + double* sep, const fortran_int_t mm, fortran_int_t& m, + std::complex* work, const fortran_int_t ldwork, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZTRSNA( &job, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, + s, sep, &mm, &m, work, &ldwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trsna. +// +template< typename Value, typename Enable = void > +struct trsna_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct trsna_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const MatrixT& t, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorSEP& sep, + const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + VectorSEP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSEP >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( job, bindings::size_column(t) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( job, ldwork, bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'S' ); + BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' ); + return detail::trsna( job, howmny, bindings::begin_value(select), + bindings::size_column(t), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), bindings::begin_value(s), + bindings::begin_value(sep), mm, m, + bindings::begin_value(work.select(real_type())), ldwork, + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const MatrixT& t, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorSEP& sep, + const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( job, + ldwork, bindings::size_column(t) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( job, bindings::size_column(t) ) ); + return invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, ldwork, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const MatrixT& t, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorSEP& sep, + const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, ldwork, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, + const std::ptrdiff_t ldwork, const std::ptrdiff_t n ) { + return job == 'E' ? 1 : ldwork * (n+6); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char job, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, job == 'E' ? 1 : 2 * (n-1)); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct trsna_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const MatrixT& t, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorSEP& sep, + const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixT >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorSEP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixT >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSEP >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( job, bindings::size_column(t) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( job, ldwork, bindings::size_column(t) )); + BOOST_ASSERT( bindings::size_column(t) >= 0 ); + BOOST_ASSERT( bindings::size_minor(t) == 1 || + bindings::stride_minor(t) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(t) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(t)) ); + BOOST_ASSERT( howmny == 'A' || howmny == 'S' ); + BOOST_ASSERT( job == 'E' || job == 'V' || job == 'B' ); + return detail::trsna( job, howmny, bindings::begin_value(select), + bindings::size_column(t), bindings::begin_value(t), + bindings::stride_major(t), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), bindings::begin_value(s), + bindings::begin_value(sep), mm, m, + bindings::begin_value(work.select(value_type())), ldwork, + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const MatrixT& t, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorSEP& sep, + const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( job, + ldwork, bindings::size_column(t) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( job, + bindings::size_column(t) ) ); + return invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, ldwork, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP > + static std::ptrdiff_t invoke( const char job, const char howmny, + const VectorSELECT& select, const MatrixT& t, const MatrixVL& vl, + const MatrixVR& vr, VectorS& s, VectorSEP& sep, + const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( job, howmny, select, t, vl, vr, s, sep, mm, m, ldwork, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char job, + const std::ptrdiff_t ldwork, const std::ptrdiff_t n ) { + return job == 'E' ? 1 : ldwork * (n+6); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char job, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, job == 'E' ? 1 : n); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trsna_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trsna. Its overload differs for +// * User-defined workspace +// +template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +trsna( const char job, const char howmny, const VectorSELECT& select, + const MatrixT& t, const MatrixVL& vl, const MatrixVR& vr, VectorS& s, + VectorSEP& sep, const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork, Workspace work ) { + return trsna_impl< typename bindings::value_type< + MatrixT >::type >::invoke( job, howmny, select, t, vl, vr, s, sep, + mm, m, ldwork, work ); +} + +// +// Overloaded function for trsna. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorSELECT, typename MatrixT, typename MatrixVL, + typename MatrixVR, typename VectorS, typename VectorSEP > +inline typename boost::disable_if< detail::is_workspace< VectorSEP >, + std::ptrdiff_t >::type +trsna( const char job, const char howmny, const VectorSELECT& select, + const MatrixT& t, const MatrixVL& vl, const MatrixVR& vr, VectorS& s, + VectorSEP& sep, const fortran_int_t mm, fortran_int_t& m, + const fortran_int_t ldwork ) { + return trsna_impl< typename bindings::value_type< + MatrixT >::type >::invoke( job, howmny, select, t, vl, vr, s, sep, + mm, m, ldwork, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trsyl.hpp b/sdk/boost/numeric/bindings/lapack/computational/trsyl.hpp new file mode 100644 index 0000000..90c28d9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trsyl.hpp @@ -0,0 +1,265 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSYL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRSYL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trsyl is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t trsyl( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const float* a, const fortran_int_t lda, + const float* b, const fortran_int_t ldb, float* c, + const fortran_int_t ldc, float& scale ) { + fortran_int_t info(0); + LAPACK_STRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c, &ldc, + &scale, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t trsyl( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const double* a, const fortran_int_t lda, + const double* b, const fortran_int_t ldb, double* c, + const fortran_int_t ldc, double& scale ) { + fortran_int_t info(0); + LAPACK_DTRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c, &ldc, + &scale, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trsyl( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, std::complex* c, + const fortran_int_t ldc, float& scale ) { + fortran_int_t info(0); + LAPACK_CTRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c, &ldc, + &scale, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t trsyl( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, std::complex* c, + const fortran_int_t ldc, double& scale ) { + fortran_int_t info(0); + LAPACK_ZTRSYL( &trana, &tranb, &isgn, &m, &n, a, &lda, b, &ldb, c, &ldc, + &scale, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trsyl. +// +template< typename Value, typename Enable = void > +struct trsyl_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct trsyl_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC > + static std::ptrdiff_t invoke( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const MatrixA& a, const MatrixB& b, + MatrixC& c, real_type& scale ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + m) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + m) ); + BOOST_ASSERT( m >= 0 ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( trana == 'N' || trana == 'T' || trana == 'C' ); + BOOST_ASSERT( tranb == 'N' || tranb == 'T' || tranb == 'C' ); + return detail::trsyl( trana, tranb, isgn, m, n, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(c), bindings::stride_major(c), scale ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct trsyl_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixC > + static std::ptrdiff_t invoke( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const MatrixA& a, const MatrixB& b, + MatrixC& c, real_type& scale ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + m) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + m) ); + BOOST_ASSERT( m >= 0 ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( trana == 'N' || trana == 'C' ); + BOOST_ASSERT( tranb == 'N' || tranb == 'C' ); + return detail::trsyl( trana, tranb, isgn, m, n, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(c), bindings::stride_major(c), scale ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trsyl_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trsyl. Its overload differs for +// +template< typename MatrixA, typename MatrixB, typename MatrixC > +inline std::ptrdiff_t trsyl( const char trana, const char tranb, + const fortran_int_t isgn, const fortran_int_t m, + const fortran_int_t n, const MatrixA& a, const MatrixB& b, + MatrixC& c, typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& scale ) { + return trsyl_impl< typename bindings::value_type< + MatrixA >::type >::invoke( trana, tranb, isgn, m, n, a, b, c, + scale ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trtri.hpp b/sdk/boost/numeric/bindings/lapack/computational/trtri.hpp new file mode 100644 index 0000000..65c3281 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trtri.hpp @@ -0,0 +1,229 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRTRI_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRTRI_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trtri is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, const int n, + float* a, const int lda ) { + return clapack_strtri( clapack_option< Order >::value, clapack_option< + UpLo >::value, clapack_option< Diag >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, const int n, + double* a, const int lda ) { + return clapack_dtrtri( clapack_option< Order >::value, clapack_option< + UpLo >::value, clapack_option< Diag >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, const int n, + std::complex* a, const int lda ) { + return clapack_ctrtri( clapack_option< Order >::value, clapack_option< + UpLo >::value, clapack_option< Diag >::value, n, a, lda ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, const int n, + std::complex* a, const int lda ) { + return clapack_ztrtri( clapack_option< Order >::value, clapack_option< + UpLo >::value, clapack_option< Diag >::value, n, a, lda ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, + const fortran_int_t n, float* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_STRTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, + const fortran_int_t n, double* a, const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DTRTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CTRTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo, typename Diag > +inline std::ptrdiff_t trtri( Order, const UpLo, const Diag, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZTRTRI( &lapack_option< UpLo >::value, &lapack_option< + Diag >::value, &n, a, &lda, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trtri. +// +template< typename Value > +struct trtri_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA > + static std::ptrdiff_t invoke( MatrixA& a ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::trtri( order(), uplo(), diag(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trtri_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trtri. Its overload differs for +// +template< typename MatrixA > +inline std::ptrdiff_t trtri( MatrixA& a ) { + return trtri_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/trtrs.hpp b/sdk/boost/numeric/bindings/lapack/computational/trtrs.hpp new file mode 100644 index 0000000..9b74784 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/trtrs.hpp @@ -0,0 +1,187 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRTRS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TRTRS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for trtrs is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_STRTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, const double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DTRTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CTRTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo, typename Trans, typename Diag > +inline std::ptrdiff_t trtrs( const UpLo, const Trans, const Diag, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZTRTRS( &lapack_option< UpLo >::value, &lapack_option< + Trans >::value, &lapack_option< Diag >::value, &n, &nrhs, a, &lda, + b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to trtrs. +// +template< typename Value > +struct trtrs_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( const MatrixA& a, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + typedef typename result_of::diag_tag< MatrixA >::type diag; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + return detail::trtrs( uplo(), trans(), diag(), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the trtrs_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for trtrs. Its overload differs for +// +template< typename MatrixA, typename MatrixB > +inline std::ptrdiff_t trtrs( const MatrixA& a, MatrixB& b ) { + return trtrs_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/tzrzf.hpp b/sdk/boost/numeric/bindings/lapack/computational/tzrzf.hpp new file mode 100644 index 0000000..9ce0e0f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/tzrzf.hpp @@ -0,0 +1,326 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TZRZF_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_TZRZF_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for tzrzf is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t tzrzf( const fortran_int_t m, const fortran_int_t n, + float* a, const fortran_int_t lda, float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_STZRZF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t tzrzf( const fortran_int_t m, const fortran_int_t n, + double* a, const fortran_int_t lda, double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DTZRZF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tzrzf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CTZRZF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t tzrzf( const fortran_int_t m, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZTZRZF( &m, &n, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to tzrzf. +// +template< typename Value, typename Enable = void > +struct tzrzf_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct tzrzf_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::tzrzf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::tzrzf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >(1,m); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct tzrzf_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorTAU >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::tzrzf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::tzrzf( bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >(1,m); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the tzrzf_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for tzrzf. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +tzrzf( MatrixA& a, VectorTAU& tau, Workspace work ) { + return tzrzf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for tzrzf. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +tzrzf( MatrixA& a, VectorTAU& tau ) { + return tzrzf_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ungbr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ungbr.hpp new file mode 100644 index 0000000..24906e0 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ungbr.hpp @@ -0,0 +1,337 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGBR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGBR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ungbr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ungbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, float* a, + const fortran_int_t lda, const float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ungbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, double* a, + const fortran_int_t lda, const double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGBR( &vect, &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ungbr. +// +template< typename Value, typename Enable = void > +struct ungbr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ungbr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( m, n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + m) ); + BOOST_ASSERT( k >= 0 ); + BOOST_ASSERT( m >= 0 ); + BOOST_ASSERT( vect == 'Q' || vect == 'P' ); + return detail::ungbr( vect, m, n, k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( m, n ) ); + return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ungbr( vect, m, n, k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, std::min< std::ptrdiff_t >( m, + n ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ungbr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( m, n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= m ); + BOOST_ASSERT( k >= 0 ); + BOOST_ASSERT( m >= 0 ); + BOOST_ASSERT( vect == 'Q' || vect == 'P' ); + return detail::ungbr( vect, m, n, k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( m, + n ) ); + return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ungbr( vect, m, n, k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( vect, m, n, k, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, std::min< std::ptrdiff_t >( m, + n ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ungbr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ungbr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ungbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau, Workspace work ) { + return ungbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, m, n, k, a, tau, work ); +} + +// +// Overloaded function for ungbr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +ungbr( const char vect, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, MatrixA& a, + const VectorTAU& tau ) { + return ungbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, m, n, k, a, tau, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unghr.hpp b/sdk/boost/numeric/bindings/lapack/computational/unghr.hpp new file mode 100644 index 0000000..6f4ab61 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unghr.hpp @@ -0,0 +1,334 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGHR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGHR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unghr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t unghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t unghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t unghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t unghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGHR( &n, &ilo, &ihi, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unghr. +// +template< typename Value, typename Enable = void > +struct unghr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unghr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( ihi, ilo )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::unghr( n, ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( ihi, + ilo ) ); + return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::unghr( n, ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ihi, + const std::ptrdiff_t ilo ) { + return ihi-ilo; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unghr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( ihi, ilo )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::unghr( n, ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( ihi, + ilo ) ); + return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, + const fortran_int_t ilo, const fortran_int_t ihi, + MatrixA& a, const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::unghr( n, ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( n, ilo, ihi, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t ihi, + const std::ptrdiff_t ilo ) { + return ihi-ilo; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unghr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unghr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, const VectorTAU& tau, + Workspace work ) { + return unghr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, ilo, ihi, a, tau, work ); +} + +// +// Overloaded function for unghr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +unghr( const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, MatrixA& a, const VectorTAU& tau ) { + return unghr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, ilo, ihi, a, tau, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unglq.hpp b/sdk/boost/numeric/bindings/lapack/computational/unglq.hpp new file mode 100644 index 0000000..edc643a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unglq.hpp @@ -0,0 +1,326 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGLQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGLQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unglq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t unglq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t unglq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t unglq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t unglq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGLQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unglq. +// +template< typename Value, typename Enable = void > +struct unglq_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unglq_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::unglq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::unglq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >( 1, m ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unglq_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::unglq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::unglq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >( 1, m ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unglq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unglq. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unglq( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return unglq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for unglq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +unglq( MatrixA& a, const VectorTAU& tau ) { + return unglq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ungql.hpp b/sdk/boost/numeric/bindings/lapack/computational/ungql.hpp new file mode 100644 index 0000000..3b6979e --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ungql.hpp @@ -0,0 +1,324 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGQL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGQL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ungql is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ungql( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ungql( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungql( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungql( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGQL( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ungql. +// +template< typename Value, typename Enable = void > +struct ungql_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ungql_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ungql( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ungql( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, n ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ungql_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ungql( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ungql( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ungql_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ungql. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ungql( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return ungql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for ungql. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +ungql( MatrixA& a, const VectorTAU& tau ) { + return ungql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ungqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ungqr.hpp new file mode 100644 index 0000000..5215ef4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ungqr.hpp @@ -0,0 +1,324 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ungqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ungqr( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ungqr( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungqr( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungqr( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGQR( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ungqr. +// +template< typename Value, typename Enable = void > +struct ungqr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ungqr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ungqr( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ungqr( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, n ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ungqr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ungqr( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ungqr( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ungqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ungqr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ungqr( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return ungqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for ungqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +ungqr( MatrixA& a, const VectorTAU& tau ) { + return ungqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ungrq.hpp b/sdk/boost/numeric/bindings/lapack/computational/ungrq.hpp new file mode 100644 index 0000000..65eb49f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ungrq.hpp @@ -0,0 +1,326 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGRQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGRQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ungrq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ungrq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, float* a, const fortran_int_t lda, + const float* tau, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ungrq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, double* a, const fortran_int_t lda, + const double* tau, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungrq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ungrq( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t k, std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGRQ( &m, &n, &k, a, &lda, tau, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ungrq. +// +template< typename Value, typename Enable = void > +struct ungrq_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ungrq_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ungrq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ungrq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >( 1, m ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ungrq_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a) )); + BOOST_ASSERT( bindings::size_column(a) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ungrq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a) ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( MatrixA& a, const VectorTAU& tau, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ungrq( bindings::size_row(a), bindings::size_column(a), + bindings::size(tau), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m ) { + return std::max< std::ptrdiff_t >( 1, m ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ungrq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ungrq. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ungrq( MatrixA& a, const VectorTAU& tau, Workspace work ) { + return ungrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, work ); +} + +// +// Overloaded function for ungrq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +ungrq( MatrixA& a, const VectorTAU& tau ) { + return ungrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/ungtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/ungtr.hpp new file mode 100644 index 0000000..cae0e1c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/ungtr.hpp @@ -0,0 +1,333 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNGTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ungtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ungtr( const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, const float* tau, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORGTR( &lapack_option< UpLo >::value, &n, a, &lda, tau, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ungtr( const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, const double* tau, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORGTR( &lapack_option< UpLo >::value, &n, a, &lda, tau, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ungtr( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNGTR( &lapack_option< UpLo >::value, &n, a, &lda, tau, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ungtr( const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNGTR( &lapack_option< UpLo >::value, &n, a, &lda, tau, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ungtr. +// +template< typename Value, typename Enable = void > +struct ungtr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ungtr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::ungtr( uplo(), n, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + return invoke( n, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::ungtr( uplo(), n, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( n, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,n-1); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ungtr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorTAU, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_ASSERT( bindings::size(tau) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= n ); + BOOST_ASSERT( n >= 0 ); + return detail::ungtr( uplo(), n, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( n ) ); + return invoke( n, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorTAU > + static std::ptrdiff_t invoke( const fortran_int_t n, MatrixA& a, + const VectorTAU& tau, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + detail::ungtr( uplo(), n, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( n, a, tau, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n-1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ungtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ungtr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorTAU, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ungtr( const fortran_int_t n, MatrixA& a, const VectorTAU& tau, + Workspace work ) { + return ungtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, a, tau, work ); +} + +// +// Overloaded function for ungtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorTAU > +inline typename boost::disable_if< detail::is_workspace< VectorTAU >, + std::ptrdiff_t >::type +ungtr( const fortran_int_t n, MatrixA& a, const VectorTAU& tau ) { + return ungtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( n, a, tau, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmbr.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmbr.hpp new file mode 100644 index 0000000..fbdb9a9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmbr.hpp @@ -0,0 +1,430 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMBR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMBR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmbr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmbr( const char vect, const Side, const Trans, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const float* a, const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMBR( &vect, &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmbr( const char vect, const Side, const Trans, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const double* a, const fortran_int_t lda, const double* tau, + double* c, const fortran_int_t ldc, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMBR( &vect, &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmbr( const char vect, const Side, const Trans, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMBR( &vect, &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmbr( const char vect, const Side, const Trans, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMBR( &vect, &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmbr. +// +template< typename Value, typename Enable = void > +struct unmbr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmbr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const char vect, const Side side, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + BOOST_ASSERT( vect == 'Q' || vect == 'P' ); + return detail::unmbr( vect, side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const char vect, const Side side, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( vect, side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const char vect, const Side side, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmbr( vect, side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( vect, side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmbr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const char vect, const Side side, + const fortran_int_t k, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + BOOST_ASSERT( k >= 0 ); + BOOST_ASSERT( vect == 'Q' || vect == 'P' ); + return detail::unmbr( vect, side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const char vect, const Side side, + const fortran_int_t k, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const char vect, const Side side, + const fortran_int_t k, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmbr( vect, side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( vect, side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmbr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmbr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmbr( const char vect, const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return unmbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, side, a, tau, c, work ); +} + +// +// Overloaded function for unmbr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmbr( const char vect, const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c ) { + return unmbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, side, a, tau, c, + optimal_workspace() ); +} + +// +// Overloaded function for unmbr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmbr( const char vect, const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, Workspace work ) { + return unmbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, side, k, a, tau, c, work ); +} + +// +// Overloaded function for unmbr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmbr( const char vect, const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c ) { + return unmbr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( vect, side, k, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmhr.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmhr.hpp new file mode 100644 index 0000000..d1a05f5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmhr.hpp @@ -0,0 +1,401 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMHR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMHR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmhr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmhr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, const float* a, const fortran_int_t lda, + const float* tau, float* c, const fortran_int_t ldc, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMHR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmhr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, const double* a, const fortran_int_t lda, + const double* tau, double* c, const fortran_int_t ldc, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMHR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmhr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, const std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* c, const fortran_int_t ldc, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMHR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmhr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t ilo, + const fortran_int_t ihi, const std::complex* a, + const fortran_int_t lda, const std::complex* tau, + std::complex* c, const fortran_int_t ldc, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMHR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &ilo, &ihi, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmhr. +// +template< typename Value, typename Enable = void > +struct unmhr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmhr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmhr( side, trans(), bindings::size_row(c), + bindings::size_column(c), ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmhr( side, trans(), bindings::size_row(c), + bindings::size_column(c), ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmhr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmhr( side, trans(), bindings::size_row(c), + bindings::size_column(c), ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmhr( side, trans(), bindings::size_row(c), + bindings::size_column(c), ilo, ihi, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, ilo, ihi, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmhr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmhr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmhr( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return unmhr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, ilo, ihi, a, tau, c, work ); +} + +// +// Overloaded function for unmhr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmhr( const Side side, const fortran_int_t ilo, + const fortran_int_t ihi, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return unmhr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, ilo, ihi, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmlq.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmlq.hpp new file mode 100644 index 0000000..d7cda78 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmlq.hpp @@ -0,0 +1,428 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMLQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMLQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmlq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmlq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMLQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmlq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMLQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmlq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMLQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmlq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMLQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmlq. +// +template< typename Value, typename Enable = void > +struct unmlq_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmlq_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size(tau)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmlq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmlq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmlq_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= k ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + k) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmlq( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmlq( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmlq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmlq. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmlq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return unmlq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for unmlq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmlq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return unmlq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +// +// Overloaded function for unmlq. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmlq( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return unmlq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, work ); +} + +// +// Overloaded function for unmlq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmlq( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c ) { + return unmlq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmql.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmql.hpp new file mode 100644 index 0000000..6040ea8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmql.hpp @@ -0,0 +1,424 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMQL_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMQL_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmql is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmql( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMQL( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmql( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMQL( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmql( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMQL( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmql( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMQL( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmql. +// +template< typename Value, typename Enable = void > +struct unmql_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmql_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmql( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmql( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmql_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= k ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmql( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmql( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmql_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmql. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmql( const Side side, MatrixA& a, const VectorTAU& tau, MatrixC& c, + Workspace work ) { + return unmql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for unmql. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmql( const Side side, MatrixA& a, const VectorTAU& tau, MatrixC& c ) { + return unmql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +// +// Overloaded function for unmql. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmql( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return unmql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, work ); +} + +// +// Overloaded function for unmql. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmql( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c ) { + return unmql_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmqr.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmqr.hpp new file mode 100644 index 0000000..41b683d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmqr.hpp @@ -0,0 +1,394 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMQR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMQR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmqr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmqr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMQR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmqr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMQR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmqr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMQR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmqr( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMQR( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmqr. +// +template< typename Value, typename Enable = void > +struct unmqr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmqr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmqr( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmqr( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmqr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmqr( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmqr( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmqr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmqr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmqr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return unmqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for unmqr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmqr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return unmqr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmrq.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmrq.hpp new file mode 100644 index 0000000..fe8ec0d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmrq.hpp @@ -0,0 +1,428 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMRQ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMRQ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmrq is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMRQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMRQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMRQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrq( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMRQ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmrq. +// +template< typename Value, typename Enable = void > +struct unmrq_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmrq_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size(tau)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmrq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmrq( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmrq_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= k ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + k) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmrq( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmrq( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmrq_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmrq. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmrq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return unmrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for unmrq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmrq( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return unmrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +// +// Overloaded function for unmrq. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmrq( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return unmrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, work ); +} + +// +// Overloaded function for unmrq. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmrq( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c ) { + return unmrq_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmrz.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmrz.hpp new file mode 100644 index 0000000..1ce2c4c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmrz.hpp @@ -0,0 +1,432 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMRZ_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMRZ_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmrz is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrz( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const fortran_int_t l, + const float* a, const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMRZ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrz( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const fortran_int_t l, + const double* a, const fortran_int_t lda, const double* tau, + double* c, const fortran_int_t ldc, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMRZ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrz( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const fortran_int_t l, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMRZ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t unmrz( const Side, const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t k, const fortran_int_t l, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMRZ( &lapack_option< Side >::value, &lapack_option< + Trans >::value, &m, &n, &k, &l, a, &lda, tau, c, &ldc, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmrz. +// +template< typename Value, typename Enable = void > +struct unmrz_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmrz_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size(tau) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size(tau)) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmrz( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::unmrz( side, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::size(tau), + bindings::size_column_op(a, trans()), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmrz_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(tau) >= k ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + k) ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmrz( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::size_column_op(a, + trans()), bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const fortran_int_t k, + const MatrixA& a, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::unmrz( side, trans(), bindings::size_row(c), + bindings::size_column(c), k, bindings::size_column_op(a, + trans()), bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, k, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmrz_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmrz. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmrz( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return unmrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for unmrz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmrz( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return unmrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +// +// Overloaded function for unmrz. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmrz( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return unmrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, work ); +} + +// +// Overloaded function for unmrz. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmrz( const Side side, const fortran_int_t k, const MatrixA& a, + const VectorTAU& tau, MatrixC& c ) { + return unmrz_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, k, a, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/unmtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/unmtr.hpp new file mode 100644 index 0000000..e8886bb --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/unmtr.hpp @@ -0,0 +1,397 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UNMTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for unmtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename UpLo, typename Trans > +inline std::ptrdiff_t unmtr( const Side, const UpLo, const Trans, + const fortran_int_t m, const fortran_int_t n, const float* a, + const fortran_int_t lda, const float* tau, float* c, + const fortran_int_t ldc, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SORMTR( &lapack_option< Side >::value, &lapack_option< + UpLo >::value, &lapack_option< Trans >::value, &m, &n, a, &lda, + tau, c, &ldc, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename UpLo, typename Trans > +inline std::ptrdiff_t unmtr( const Side, const UpLo, const Trans, + const fortran_int_t m, const fortran_int_t n, const double* a, + const fortran_int_t lda, const double* tau, double* c, + const fortran_int_t ldc, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DORMTR( &lapack_option< Side >::value, &lapack_option< + UpLo >::value, &lapack_option< Trans >::value, &m, &n, a, &lda, + tau, c, &ldc, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename UpLo, typename Trans > +inline std::ptrdiff_t unmtr( const Side, const UpLo, const Trans, + const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CUNMTR( &lapack_option< Side >::value, &lapack_option< + UpLo >::value, &lapack_option< Trans >::value, &m, &n, a, &lda, + tau, c, &ldc, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename UpLo, typename Trans > +inline std::ptrdiff_t unmtr( const Side, const UpLo, const Trans, + const fortran_int_t m, const fortran_int_t n, + const std::complex* a, const fortran_int_t lda, + const std::complex* tau, std::complex* c, + const fortran_int_t ldc, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZUNMTR( &lapack_option< Side >::value, &lapack_option< + UpLo >::value, &lapack_option< Trans >::value, &m, &n, a, &lda, + tau, c, &ldc, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to unmtr. +// +template< typename Value, typename Enable = void > +struct unmtr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct unmtr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmtr( side, uplo(), trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + real_type opt_size_work; + detail::unmtr( side, uplo(), trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct unmtr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::unmtr( side, uplo(), trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const MatrixA& a, + const VectorTAU& tau, MatrixC& c, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixC >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + typedef typename result_of::uplo_tag< MatrixA, trans >::type uplo; + value_type opt_size_work; + detail::unmtr( side, uplo(), trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(tau), + bindings::begin_value(c), bindings::stride_major(c), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( side, a, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the unmtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for unmtr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +unmtr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c, Workspace work ) { + return unmtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, work ); +} + +// +// Overloaded function for unmtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename MatrixA, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +unmtr( const Side side, const MatrixA& a, const VectorTAU& tau, + MatrixC& c ) { + return unmtr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( side, a, tau, c, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/upgtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/upgtr.hpp new file mode 100644 index 0000000..499589b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/upgtr.hpp @@ -0,0 +1,328 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UPGTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UPGTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for upgtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t upgtr( const char uplo, const fortran_int_t n, + const float* ap, const float* tau, float* q, const fortran_int_t ldq, + float* work ) { + fortran_int_t info(0); + LAPACK_SOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t upgtr( const char uplo, const fortran_int_t n, + const double* ap, const double* tau, double* q, + const fortran_int_t ldq, double* work ) { + fortran_int_t info(0); + LAPACK_DOPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t upgtr( const char uplo, const fortran_int_t n, + const std::complex* ap, const std::complex* tau, + std::complex* q, const fortran_int_t ldq, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CUPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t upgtr( const char uplo, const fortran_int_t n, + const std::complex* ap, const std::complex* tau, + std::complex* q, const fortran_int_t ldq, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZUPGTR( &uplo, &n, ap, tau, q, &ldq, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to upgtr. +// +template< typename Value, typename Enable = void > +struct upgtr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct upgtr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ, + typename WORK > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(ap) >= + bindings::size_column(q)*(bindings::size_column(q)+1)/2 ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(q)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(q) )); + BOOST_ASSERT( bindings::size_column(q) >= 0 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(q)) ); + return detail::upgtr( uplo, bindings::size_column(q), + bindings::begin_value(ap), bindings::begin_value(tau), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(q) ) ); + return invoke( uplo, ap, tau, q, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, ap, tau, q, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n-1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct upgtr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ, + typename WORK > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(ap) >= + bindings::size_column(q)*(bindings::size_column(q)+1)/2 ); + BOOST_ASSERT( bindings::size(tau) >= bindings::size_column(q)-1 ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(q) )); + BOOST_ASSERT( bindings::size_column(q) >= 0 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(q)) ); + return detail::upgtr( uplo, bindings::size_column(q), + bindings::begin_value(ap), bindings::begin_value(tau), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(q) ) ); + return invoke( uplo, ap, tau, q, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorAP, typename VectorTAU, typename MatrixQ > + static std::ptrdiff_t invoke( const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( uplo, ap, tau, q, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n-1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the upgtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for upgtr. Its overload differs for +// * User-defined workspace +// +template< typename VectorAP, typename VectorTAU, typename MatrixQ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +upgtr( const char uplo, const VectorAP& ap, const VectorTAU& tau, + MatrixQ& q, Workspace work ) { + return upgtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( uplo, ap, tau, q, work ); +} + +// +// Overloaded function for upgtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorAP, typename VectorTAU, typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +upgtr( const char uplo, const VectorAP& ap, const VectorTAU& tau, + MatrixQ& q ) { + return upgtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( uplo, ap, tau, q, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/computational/upmtr.hpp b/sdk/boost/numeric/bindings/lapack/computational/upmtr.hpp new file mode 100644 index 0000000..70b6188 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/computational/upmtr.hpp @@ -0,0 +1,366 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UPMTR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_UPMTR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for upmtr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t upmtr( const Side, const char uplo, const Trans, + const fortran_int_t m, const fortran_int_t n, const float* ap, + const float* tau, float* c, const fortran_int_t ldc, float* work ) { + fortran_int_t info(0); + LAPACK_SOPMTR( &lapack_option< Side >::value, &uplo, &lapack_option< + Trans >::value, &m, &n, ap, tau, c, &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t upmtr( const Side, const char uplo, const Trans, + const fortran_int_t m, const fortran_int_t n, const double* ap, + const double* tau, double* c, const fortran_int_t ldc, double* work ) { + fortran_int_t info(0); + LAPACK_DOPMTR( &lapack_option< Side >::value, &uplo, &lapack_option< + Trans >::value, &m, &n, ap, tau, c, &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t upmtr( const Side, const char uplo, const Trans, + const fortran_int_t m, const fortran_int_t n, + const std::complex* ap, const std::complex* tau, + std::complex* c, const fortran_int_t ldc, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_CUPMTR( &lapack_option< Side >::value, &uplo, &lapack_option< + Trans >::value, &m, &n, ap, tau, c, &ldc, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Side, typename Trans > +inline std::ptrdiff_t upmtr( const Side, const char uplo, const Trans, + const fortran_int_t m, const fortran_int_t n, + const std::complex* ap, const std::complex* tau, + std::complex* c, const fortran_int_t ldc, + std::complex* work ) { + fortran_int_t info(0); + LAPACK_ZUPMTR( &lapack_option< Side >::value, &uplo, &lapack_option< + Trans >::value, &m, &n, ap, tau, c, &ldc, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to upmtr. +// +template< typename Value, typename Enable = void > +struct upmtr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct upmtr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::upmtr( side, uplo, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(ap), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + return invoke( side, uplo, ap, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct upmtr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC, typename WORK > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixC >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorTAU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixC >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( side, bindings::size_row(c), + bindings::size_column(c) )); + BOOST_ASSERT( bindings::size_column(c) >= 0 ); + BOOST_ASSERT( bindings::size_minor(c) == 1 || + bindings::stride_minor(c) == 1 ); + BOOST_ASSERT( bindings::size_row(c) >= 0 ); + BOOST_ASSERT( bindings::stride_major(c) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(c)) ); + return detail::upmtr( side, uplo, trans(), bindings::size_row(c), + bindings::size_column(c), bindings::begin_value(ap), + bindings::begin_value(tau), bindings::begin_value(c), + bindings::stride_major(c), + bindings::begin_value(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( side, + bindings::size_row(c), bindings::size_column(c) ) ); + return invoke( side, uplo, ap, tau, c, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > + static std::ptrdiff_t invoke( const Side side, const char uplo, + const VectorAP& ap, const VectorTAU& tau, MatrixC& c, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorAP, order >::type trans; + return invoke( side, uplo, ap, tau, c, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + template< typename Side > + static std::ptrdiff_t min_size_work( const Side side, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, bindings::detail::if_left( side, + n, m ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the upmtr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for upmtr. Its overload differs for +// * User-defined workspace +// +template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +upmtr( const Side side, const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixC& c, Workspace work ) { + return upmtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( side, uplo, ap, tau, c, work ); +} + +// +// Overloaded function for upmtr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename Side, typename VectorAP, typename VectorTAU, + typename MatrixC > +inline typename boost::disable_if< detail::is_workspace< MatrixC >, + std::ptrdiff_t >::type +upmtr( const Side side, const char uplo, const VectorAP& ap, + const VectorTAU& tau, MatrixC& c ) { + return upmtr_impl< typename bindings::value_type< + VectorAP >::type >::invoke( side, uplo, ap, tau, c, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/detail/clapack.h b/sdk/boost/numeric/bindings/lapack/detail/clapack.h new file mode 100644 index 0000000..cd29dca --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/detail/clapack.h @@ -0,0 +1,18 @@ +// +// Copyright (c) 2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_CLAPACK_H +#define BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_CLAPACK_H + +extern "C" { +#include +} + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/detail/clapack_option.hpp b/sdk/boost/numeric/bindings/lapack/detail/clapack_option.hpp new file mode 100644 index 0000000..0106f6c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/detail/clapack_option.hpp @@ -0,0 +1,29 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_CLAPACK_OPTION_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_CLAPACK_OPTION_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { +namespace detail { + +template< typename Tag > +struct clapack_option: blas::detail::cblas_option< Tag > {}; + +} // namespace detail +} // namespace blas +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/detail/lapack.h b/sdk/boost/numeric/bindings/lapack/detail/lapack.h new file mode 100644 index 0000000..010c035 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/detail/lapack.h @@ -0,0 +1,4380 @@ +// +// Copyright (c) 2003--2009 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_LAPACK_H +#define BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_LAPACK_H + +#include + +extern "C" { + +// +// LAPACK computational routines +// + +// Value-type variants of hbgst +void LAPACK_CHBGST( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, void* ab, const fortran_int_t* ldab, + const void* bb, const fortran_int_t* ldbb, void* x, + const fortran_int_t* ldx, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHBGST( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, void* ab, const fortran_int_t* ldab, + const void* bb, const fortran_int_t* ldbb, void* x, + const fortran_int_t* ldx, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of hegst +void LAPACK_CHEGST( const fortran_int_t* itype, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + const void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZHEGST( const fortran_int_t* itype, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + const void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of pbstf +void LAPACK_SPBSTF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, float* ab, const fortran_int_t* ldab, + fortran_int_t* info ); +void LAPACK_DPBSTF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, double* ab, const fortran_int_t* ldab, + fortran_int_t* info ); +void LAPACK_CPBSTF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, void* ab, const fortran_int_t* ldab, + fortran_int_t* info ); +void LAPACK_ZPBSTF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, void* ab, const fortran_int_t* ldab, + fortran_int_t* info ); + +// Value-type variants of sbgst +void LAPACK_SSBGST( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, float* ab, const fortran_int_t* ldab, + const float* bb, const fortran_int_t* ldbb, float* x, + const fortran_int_t* ldx, float* work, fortran_int_t* info ); +void LAPACK_DSBGST( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, double* ab, const fortran_int_t* ldab, + const double* bb, const fortran_int_t* ldbb, double* x, + const fortran_int_t* ldx, double* work, fortran_int_t* info ); + +// Value-type variants of sygst +void LAPACK_SSYGST( const fortran_int_t* itype, const char* uplo, + const fortran_int_t* n, float* a, const fortran_int_t* lda, + const float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DSYGST( const fortran_int_t* itype, const char* uplo, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + const double* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of ggqrf +void LAPACK_SGGQRF( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, float* a, const fortran_int_t* lda, + float* taua, float* b, const fortran_int_t* ldb, float* taub, + float* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGGQRF( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, double* a, const fortran_int_t* lda, + double* taua, double* b, const fortran_int_t* ldb, double* taub, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGGQRF( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, void* a, const fortran_int_t* lda, void* taua, + void* b, const fortran_int_t* ldb, void* taub, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGGQRF( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, void* a, const fortran_int_t* lda, void* taua, + void* b, const fortran_int_t* ldb, void* taub, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ggrqf +void LAPACK_SGGRQF( const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, float* a, const fortran_int_t* lda, + float* taua, float* b, const fortran_int_t* ldb, float* taub, + float* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGGRQF( const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* taua, double* b, const fortran_int_t* ldb, double* taub, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGGRQF( const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* taua, + void* b, const fortran_int_t* ldb, void* taub, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGGRQF( const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* taua, + void* b, const fortran_int_t* ldb, void* taub, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of gelqf +void LAPACK_SGELQF( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGELQF( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGELQF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGELQF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of geqlf +void LAPACK_SGEQLF( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGEQLF( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGEQLF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGEQLF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of geqp3 +void LAPACK_SGEQP3( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* jpvt, float* tau, + float* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGEQP3( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* jpvt, double* tau, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGEQP3( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* jpvt, void* tau, void* work, + const fortran_int_t* lwork, float* rwork, fortran_int_t* info ); +void LAPACK_ZGEQP3( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* jpvt, void* tau, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* info ); + +// Value-type variants of geqrf +void LAPACK_SGEQRF( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGEQRF( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGEQRF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGEQRF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of gerqf +void LAPACK_SGERQF( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGERQF( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGERQF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGERQF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of orglq +void LAPACK_SORGLQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, float* a, const fortran_int_t* lda, + const float* tau, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORGLQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, double* a, const fortran_int_t* lda, + const double* tau, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of orgql +void LAPACK_SORGQL( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, float* a, const fortran_int_t* lda, + const float* tau, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORGQL( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, double* a, const fortran_int_t* lda, + const double* tau, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of orgqr +void LAPACK_SORGQR( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, float* a, const fortran_int_t* lda, + const float* tau, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORGQR( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, double* a, const fortran_int_t* lda, + const double* tau, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of orgrq +void LAPACK_SORGRQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, float* a, const fortran_int_t* lda, + const float* tau, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORGRQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, double* a, const fortran_int_t* lda, + const double* tau, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of ormlq +void LAPACK_SORMLQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const float* a, const fortran_int_t* lda, + const float* tau, float* c, const fortran_int_t* ldc, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORMLQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const double* a, const fortran_int_t* lda, + const double* tau, double* c, const fortran_int_t* ldc, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ormql +void LAPACK_SORMQL( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, float* a, const fortran_int_t* lda, + const float* tau, float* c, const fortran_int_t* ldc, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORMQL( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, double* a, const fortran_int_t* lda, + const double* tau, double* c, const fortran_int_t* ldc, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ormqr +void LAPACK_SORMQR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const float* a, const fortran_int_t* lda, + const float* tau, float* c, const fortran_int_t* ldc, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORMQR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const double* a, const fortran_int_t* lda, + const double* tau, double* c, const fortran_int_t* ldc, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ormrq +void LAPACK_SORMRQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const float* a, const fortran_int_t* lda, + const float* tau, float* c, const fortran_int_t* ldc, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORMRQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const double* a, const fortran_int_t* lda, + const double* tau, double* c, const fortran_int_t* ldc, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ormrz +void LAPACK_SORMRZ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const fortran_int_t* l, const float* a, + const fortran_int_t* lda, const float* tau, float* c, + const fortran_int_t* ldc, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORMRZ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const fortran_int_t* l, const double* a, + const fortran_int_t* lda, const double* tau, double* c, + const fortran_int_t* ldc, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of tzrzf +void LAPACK_STZRZF( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DTZRZF( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CTZRZF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZTZRZF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unglq +void LAPACK_CUNGLQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNGLQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of ungql +void LAPACK_CUNGQL( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNGQL( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of ungqr +void LAPACK_CUNGQR( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNGQR( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of ungrq +void LAPACK_CUNGRQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNGRQ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of unmlq +void LAPACK_CUNMLQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNMLQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unmql +void LAPACK_CUNMQL( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNMQL( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unmqr +void LAPACK_CUNMQR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNMQR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unmrq +void LAPACK_CUNMRQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNMRQ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unmrz +void LAPACK_CUNMRZ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const fortran_int_t* l, const void* a, + const fortran_int_t* lda, const void* tau, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNMRZ( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const fortran_int_t* l, const void* a, + const fortran_int_t* lda, const void* tau, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of bdsdc +void LAPACK_SBDSDC( const char* uplo, const char* compq, + const fortran_int_t* n, float* d, float* e, float* u, + const fortran_int_t* ldu, float* vt, const fortran_int_t* ldvt, + float* q, fortran_int_t* iq, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DBDSDC( const char* uplo, const char* compq, + const fortran_int_t* n, double* d, double* e, double* u, + const fortran_int_t* ldu, double* vt, const fortran_int_t* ldvt, + double* q, fortran_int_t* iq, double* work, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of bdsqr +void LAPACK_SBDSQR( const char* uplo, const fortran_int_t* n, + const fortran_int_t* ncvt, const fortran_int_t* nru, + const fortran_int_t* ncc, float* d, float* e, float* vt, + const fortran_int_t* ldvt, float* u, const fortran_int_t* ldu, + float* c, const fortran_int_t* ldc, float* work, fortran_int_t* info ); +void LAPACK_DBDSQR( const char* uplo, const fortran_int_t* n, + const fortran_int_t* ncvt, const fortran_int_t* nru, + const fortran_int_t* ncc, double* d, double* e, double* vt, + const fortran_int_t* ldvt, double* u, const fortran_int_t* ldu, + double* c, const fortran_int_t* ldc, double* work, + fortran_int_t* info ); +void LAPACK_CBDSQR( const char* uplo, const fortran_int_t* n, + const fortran_int_t* ncvt, const fortran_int_t* nru, + const fortran_int_t* ncc, float* d, float* e, void* vt, + const fortran_int_t* ldvt, void* u, const fortran_int_t* ldu, void* c, + const fortran_int_t* ldc, float* rwork, fortran_int_t* info ); +void LAPACK_ZBDSQR( const char* uplo, const fortran_int_t* n, + const fortran_int_t* ncvt, const fortran_int_t* nru, + const fortran_int_t* ncc, double* d, double* e, void* vt, + const fortran_int_t* ldvt, void* u, const fortran_int_t* ldu, void* c, + const fortran_int_t* ldc, double* rwork, fortran_int_t* info ); + +// Value-type variants of gbbrd +void LAPACK_SGBBRD( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* ncc, + const fortran_int_t* kl, const fortran_int_t* ku, float* ab, + const fortran_int_t* ldab, float* d, float* e, float* q, + const fortran_int_t* ldq, float* pt, const fortran_int_t* ldpt, + float* c, const fortran_int_t* ldc, float* work, fortran_int_t* info ); +void LAPACK_DGBBRD( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* ncc, + const fortran_int_t* kl, const fortran_int_t* ku, double* ab, + const fortran_int_t* ldab, double* d, double* e, double* q, + const fortran_int_t* ldq, double* pt, const fortran_int_t* ldpt, + double* c, const fortran_int_t* ldc, double* work, + fortran_int_t* info ); +void LAPACK_CGBBRD( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* ncc, + const fortran_int_t* kl, const fortran_int_t* ku, void* ab, + const fortran_int_t* ldab, float* d, float* e, void* q, + const fortran_int_t* ldq, void* pt, const fortran_int_t* ldpt, + void* c, const fortran_int_t* ldc, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGBBRD( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* ncc, + const fortran_int_t* kl, const fortran_int_t* ku, void* ab, + const fortran_int_t* ldab, double* d, double* e, void* q, + const fortran_int_t* ldq, void* pt, const fortran_int_t* ldpt, + void* c, const fortran_int_t* ldc, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gebrd +void LAPACK_SGEBRD( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* d, float* e, float* tauq, + float* taup, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DGEBRD( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* d, double* e, double* tauq, + double* taup, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_CGEBRD( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, float* d, float* e, void* tauq, void* taup, + void* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGEBRD( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, double* d, double* e, void* tauq, + void* taup, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of orgbr +void LAPACK_SORGBR( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* k, float* a, + const fortran_int_t* lda, const float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORGBR( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* k, double* a, + const fortran_int_t* lda, const double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ormbr +void LAPACK_SORMBR( const char* vect, const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const float* a, const fortran_int_t* lda, + const float* tau, float* c, const fortran_int_t* ldc, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORMBR( const char* vect, const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const double* a, const fortran_int_t* lda, + const double* tau, double* c, const fortran_int_t* ldc, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ungbr +void LAPACK_CUNGBR( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* k, void* a, + const fortran_int_t* lda, const void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNGBR( const char* vect, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* k, void* a, + const fortran_int_t* lda, const void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unmbr +void LAPACK_CUNMBR( const char* vect, const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNMBR( const char* vect, const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* a, const fortran_int_t* lda, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of gebak +void LAPACK_SGEBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const float* scale, const fortran_int_t* m, float* v, + const fortran_int_t* ldv, fortran_int_t* info ); +void LAPACK_DGEBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const double* scale, const fortran_int_t* m, double* v, + const fortran_int_t* ldv, fortran_int_t* info ); +void LAPACK_CGEBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const float* scale, const fortran_int_t* m, void* v, + const fortran_int_t* ldv, fortran_int_t* info ); +void LAPACK_ZGEBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const double* scale, const fortran_int_t* m, void* v, + const fortran_int_t* ldv, fortran_int_t* info ); + +// Value-type variants of gebal +void LAPACK_SGEBAL( const char* job, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* ilo, fortran_int_t* ihi, + float* scale, fortran_int_t* info ); +void LAPACK_DGEBAL( const char* job, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* ilo, fortran_int_t* ihi, + double* scale, fortran_int_t* info ); +void LAPACK_CGEBAL( const char* job, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ilo, fortran_int_t* ihi, + float* scale, fortran_int_t* info ); +void LAPACK_ZGEBAL( const char* job, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ilo, fortran_int_t* ihi, + double* scale, fortran_int_t* info ); + +// Value-type variants of gehrd +void LAPACK_SGEHRD( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, float* a, const fortran_int_t* lda, + float* tau, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DGEHRD( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, double* a, const fortran_int_t* lda, + double* tau, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_CGEHRD( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* a, const fortran_int_t* lda, + void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZGEHRD( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* a, const fortran_int_t* lda, + void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of hsein +void LAPACK_SHSEIN( const char* side, const char* eigsrc, const char* initv, + fortran_bool_t* select, const fortran_int_t* n, const float* h, + const fortran_int_t* ldh, float* wr, const float* wi, float* vl, + const fortran_int_t* ldvl, float* vr, const fortran_int_t* ldvr, + const fortran_int_t* mm, fortran_int_t* m, float* work, + fortran_int_t* ifaill, fortran_int_t* ifailr, fortran_int_t* info ); +void LAPACK_DHSEIN( const char* side, const char* eigsrc, const char* initv, + fortran_bool_t* select, const fortran_int_t* n, const double* h, + const fortran_int_t* ldh, double* wr, const double* wi, double* vl, + const fortran_int_t* ldvl, double* vr, const fortran_int_t* ldvr, + const fortran_int_t* mm, fortran_int_t* m, double* work, + fortran_int_t* ifaill, fortran_int_t* ifailr, fortran_int_t* info ); +void LAPACK_CHSEIN( const char* side, const char* eigsrc, const char* initv, + const fortran_bool_t* select, const fortran_int_t* n, const void* h, + const fortran_int_t* ldh, void* w, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + const fortran_int_t* mm, fortran_int_t* m, void* work, float* rwork, + fortran_int_t* ifaill, fortran_int_t* ifailr, fortran_int_t* info ); +void LAPACK_ZHSEIN( const char* side, const char* eigsrc, const char* initv, + const fortran_bool_t* select, const fortran_int_t* n, const void* h, + const fortran_int_t* ldh, void* w, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + const fortran_int_t* mm, fortran_int_t* m, void* work, double* rwork, + fortran_int_t* ifaill, fortran_int_t* ifailr, fortran_int_t* info ); + +// Value-type variants of hseqr +void LAPACK_SHSEQR( const char* job, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, float* h, const fortran_int_t* ldh, + float* wr, float* wi, float* z, const fortran_int_t* ldz, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DHSEQR( const char* job, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, double* h, const fortran_int_t* ldh, + double* wr, double* wi, double* z, const fortran_int_t* ldz, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CHSEQR( const char* job, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* h, const fortran_int_t* ldh, void* w, + void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZHSEQR( const char* job, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* h, const fortran_int_t* ldh, void* w, + void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of orghr +void LAPACK_SORGHR( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, float* a, const fortran_int_t* lda, + const float* tau, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORGHR( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, double* a, const fortran_int_t* lda, + const double* tau, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of ormhr +void LAPACK_SORMHR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, const float* a, + const fortran_int_t* lda, const float* tau, float* c, + const fortran_int_t* ldc, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORMHR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, const double* a, + const fortran_int_t* lda, const double* tau, double* c, + const fortran_int_t* ldc, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of trevc +void LAPACK_STREVC( const char* side, const char* howmny, + fortran_bool_t* select, const fortran_int_t* n, const float* t, + const fortran_int_t* ldt, float* vl, const fortran_int_t* ldvl, + float* vr, const fortran_int_t* ldvr, const fortran_int_t* mm, + fortran_int_t* m, float* work, fortran_int_t* info ); +void LAPACK_DTREVC( const char* side, const char* howmny, + fortran_bool_t* select, const fortran_int_t* n, const double* t, + const fortran_int_t* ldt, double* vl, const fortran_int_t* ldvl, + double* vr, const fortran_int_t* ldvr, const fortran_int_t* mm, + fortran_int_t* m, double* work, fortran_int_t* info ); +void LAPACK_CTREVC( const char* side, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, void* t, + const fortran_int_t* ldt, void* vl, const fortran_int_t* ldvl, + void* vr, const fortran_int_t* ldvr, const fortran_int_t* mm, + fortran_int_t* m, void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZTREVC( const char* side, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, void* t, + const fortran_int_t* ldt, void* vl, const fortran_int_t* ldvl, + void* vr, const fortran_int_t* ldvr, const fortran_int_t* mm, + fortran_int_t* m, void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of trexc +void LAPACK_STREXC( const char* compq, const fortran_int_t* n, float* t, + const fortran_int_t* ldt, float* q, const fortran_int_t* ldq, + fortran_int_t* ifst, fortran_int_t* ilst, float* work, + fortran_int_t* info ); +void LAPACK_DTREXC( const char* compq, const fortran_int_t* n, double* t, + const fortran_int_t* ldt, double* q, const fortran_int_t* ldq, + fortran_int_t* ifst, fortran_int_t* ilst, double* work, + fortran_int_t* info ); +void LAPACK_CTREXC( const char* compq, const fortran_int_t* n, void* t, + const fortran_int_t* ldt, void* q, const fortran_int_t* ldq, + const fortran_int_t* ifst, const fortran_int_t* ilst, + fortran_int_t* info ); +void LAPACK_ZTREXC( const char* compq, const fortran_int_t* n, void* t, + const fortran_int_t* ldt, void* q, const fortran_int_t* ldq, + const fortran_int_t* ifst, const fortran_int_t* ilst, + fortran_int_t* info ); + +// Value-type variants of trsen +void LAPACK_CTRSEN( const char* job, const char* compq, + const fortran_bool_t* select, const fortran_int_t* n, void* t, + const fortran_int_t* ldt, void* q, const fortran_int_t* ldq, void* w, + fortran_int_t* m, float* s, float* sep, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZTRSEN( const char* job, const char* compq, + const fortran_bool_t* select, const fortran_int_t* n, void* t, + const fortran_int_t* ldt, void* q, const fortran_int_t* ldq, void* w, + fortran_int_t* m, double* s, double* sep, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of trsna +void LAPACK_STRSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const float* t, + const fortran_int_t* ldt, const float* vl, const fortran_int_t* ldvl, + const float* vr, const fortran_int_t* ldvr, float* s, float* sep, + const fortran_int_t* mm, fortran_int_t* m, float* work, + const fortran_int_t* ldwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DTRSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const double* t, + const fortran_int_t* ldt, const double* vl, const fortran_int_t* ldvl, + const double* vr, const fortran_int_t* ldvr, double* s, double* sep, + const fortran_int_t* mm, fortran_int_t* m, double* work, + const fortran_int_t* ldwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CTRSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const void* t, + const fortran_int_t* ldt, const void* vl, const fortran_int_t* ldvl, + const void* vr, const fortran_int_t* ldvr, float* s, float* sep, + const fortran_int_t* mm, fortran_int_t* m, void* work, + const fortran_int_t* ldwork, float* rwork, fortran_int_t* info ); +void LAPACK_ZTRSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const void* t, + const fortran_int_t* ldt, const void* vl, const fortran_int_t* ldvl, + const void* vr, const fortran_int_t* ldvr, double* s, double* sep, + const fortran_int_t* mm, fortran_int_t* m, void* work, + const fortran_int_t* ldwork, double* rwork, fortran_int_t* info ); + +// Value-type variants of trsyl +void LAPACK_STRSYL( const char* trana, const char* tranb, + const fortran_int_t* isgn, const fortran_int_t* m, + const fortran_int_t* n, const float* a, const fortran_int_t* lda, + const float* b, const fortran_int_t* ldb, float* c, + const fortran_int_t* ldc, float* scale, fortran_int_t* info ); +void LAPACK_DTRSYL( const char* trana, const char* tranb, + const fortran_int_t* isgn, const fortran_int_t* m, + const fortran_int_t* n, const double* a, const fortran_int_t* lda, + const double* b, const fortran_int_t* ldb, double* c, + const fortran_int_t* ldc, double* scale, fortran_int_t* info ); +void LAPACK_CTRSYL( const char* trana, const char* tranb, + const fortran_int_t* isgn, const fortran_int_t* m, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + const void* b, const fortran_int_t* ldb, void* c, + const fortran_int_t* ldc, float* scale, fortran_int_t* info ); +void LAPACK_ZTRSYL( const char* trana, const char* tranb, + const fortran_int_t* isgn, const fortran_int_t* m, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + const void* b, const fortran_int_t* ldb, void* c, + const fortran_int_t* ldc, double* scale, fortran_int_t* info ); + +// Value-type variants of unghr +void LAPACK_CUNGHR( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNGHR( const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* a, const fortran_int_t* lda, + const void* tau, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of unmhr +void LAPACK_CUNMHR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, const void* a, + const fortran_int_t* lda, const void* tau, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNMHR( const char* side, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, const void* a, + const fortran_int_t* lda, const void* tau, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of gbcon +void LAPACK_SGBCON( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const float* ab, + const fortran_int_t* ldab, const fortran_int_t* ipiv, + const float* anorm, float* rcond, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DGBCON( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const double* ab, + const fortran_int_t* ldab, const fortran_int_t* ipiv, + const double* anorm, double* rcond, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGBCON( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const void* ab, + const fortran_int_t* ldab, const fortran_int_t* ipiv, + const float* anorm, float* rcond, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGBCON( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const void* ab, + const fortran_int_t* ldab, const fortran_int_t* ipiv, + const double* anorm, double* rcond, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gbequ +void LAPACK_SGBEQU( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const float* ab, + const fortran_int_t* ldab, float* r, float* c, float* rowcnd, + float* colcnd, float* amax, fortran_int_t* info ); +void LAPACK_DGBEQU( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const double* ab, + const fortran_int_t* ldab, double* r, double* c, double* rowcnd, + double* colcnd, double* amax, fortran_int_t* info ); +void LAPACK_CGBEQU( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const void* ab, + const fortran_int_t* ldab, float* r, float* c, float* rowcnd, + float* colcnd, float* amax, fortran_int_t* info ); +void LAPACK_ZGBEQU( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const void* ab, + const fortran_int_t* ldab, double* r, double* c, double* rowcnd, + double* colcnd, double* amax, fortran_int_t* info ); + +// Value-type variants of gbrfs +void LAPACK_SGBRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const float* ab, const fortran_int_t* ldab, + const float* afb, const fortran_int_t* ldafb, + const fortran_int_t* ipiv, const float* b, const fortran_int_t* ldb, + float* x, const fortran_int_t* ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGBRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const double* ab, + const fortran_int_t* ldab, const double* afb, + const fortran_int_t* ldafb, const fortran_int_t* ipiv, + const double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGBRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + const void* afb, const fortran_int_t* ldafb, + const fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZGBRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + const void* afb, const fortran_int_t* ldafb, + const fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of gbtrf +void LAPACK_SGBTRF( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, float* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_DGBTRF( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, double* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_CGBTRF( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, void* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_ZGBTRF( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, void* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, fortran_int_t* info ); + +// Value-type variants of gbtrs +void LAPACK_SGBTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const float* ab, const fortran_int_t* ldab, + const fortran_int_t* ipiv, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DGBTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const double* ab, + const fortran_int_t* ldab, const fortran_int_t* ipiv, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CGBTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZGBTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of gecon +void LAPACK_SGECON( const char* norm, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, const float* anorm, float* rcond, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGECON( const char* norm, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, const double* anorm, double* rcond, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGECON( const char* norm, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const float* anorm, float* rcond, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZGECON( const char* norm, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const double* anorm, double* rcond, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of geequ +void LAPACK_SGEEQU( const fortran_int_t* m, const fortran_int_t* n, + const float* a, const fortran_int_t* lda, float* r, float* c, + float* rowcnd, float* colcnd, float* amax, fortran_int_t* info ); +void LAPACK_DGEEQU( const fortran_int_t* m, const fortran_int_t* n, + const double* a, const fortran_int_t* lda, double* r, double* c, + double* rowcnd, double* colcnd, double* amax, fortran_int_t* info ); +void LAPACK_CGEEQU( const fortran_int_t* m, const fortran_int_t* n, + const void* a, const fortran_int_t* lda, float* r, float* c, + float* rowcnd, float* colcnd, float* amax, fortran_int_t* info ); +void LAPACK_ZGEEQU( const fortran_int_t* m, const fortran_int_t* n, + const void* a, const fortran_int_t* lda, double* r, double* c, + double* rowcnd, double* colcnd, double* amax, fortran_int_t* info ); + +// Value-type variants of gerfs +void LAPACK_SGERFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* a, const fortran_int_t* lda, + const float* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGERFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* a, const fortran_int_t* lda, + const double* af, const fortran_int_t* ldaf, + const fortran_int_t* ipiv, const double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGERFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* ferr, float* berr, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZGERFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* ferr, double* berr, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of getrf +void LAPACK_SGETRF( const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_DGETRF( const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_CGETRF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_ZGETRF( const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, fortran_int_t* info ); + +// Value-type variants of getri +void LAPACK_SGETRI( const fortran_int_t* n, float* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGETRI( const fortran_int_t* n, double* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGETRI( const fortran_int_t* n, void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZGETRI( const fortran_int_t* n, void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of getrs +void LAPACK_SGETRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DGETRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CGETRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZGETRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of gtrfs +void LAPACK_SGTRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* dl, const float* d, + const float* du, const float* dlf, const float* df, const float* duf, + const float* du2, const fortran_int_t* ipiv, const float* b, + const fortran_int_t* ldb, float* x, const fortran_int_t* ldx, + float* ferr, float* berr, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DGTRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* dl, const double* d, + const double* du, const double* dlf, const double* df, + const double* duf, const double* du2, const fortran_int_t* ipiv, + const double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGTRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* dl, const void* d, + const void* du, const void* dlf, const void* df, const void* duf, + const void* du2, const fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGTRFS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* dl, const void* d, + const void* du, const void* dlf, const void* df, const void* duf, + const void* du2, const fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gttrs +void LAPACK_SGTTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* dl, const float* d, + const float* du, const float* du2, const fortran_int_t* ipiv, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DGTTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* dl, const double* d, + const double* du, const double* du2, const fortran_int_t* ipiv, + double* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CGTTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* dl, const void* d, + const void* du, const void* du2, const fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZGTTRS( const char* trans, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* dl, const void* d, + const void* du, const void* du2, const fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of hecon +void LAPACK_CHECON( const char* uplo, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, + const float* anorm, float* rcond, void* work, fortran_int_t* info ); +void LAPACK_ZHECON( const char* uplo, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, + const double* anorm, double* rcond, void* work, fortran_int_t* info ); + +// Value-type variants of herfs +void LAPACK_CHERFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* ferr, float* berr, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZHERFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* ferr, double* berr, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of hetrf +void LAPACK_CHETRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZHETRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of hetri +void LAPACK_CHETRI( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, void* work, + fortran_int_t* info ); +void LAPACK_ZHETRI( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, void* work, + fortran_int_t* info ); + +// Value-type variants of hetrs +void LAPACK_CHETRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZHETRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of hpcon +void LAPACK_CHPCON( const char* uplo, const fortran_int_t* n, const void* ap, + const fortran_int_t* ipiv, const float* anorm, float* rcond, + void* work, fortran_int_t* info ); +void LAPACK_ZHPCON( const char* uplo, const fortran_int_t* n, const void* ap, + const fortran_int_t* ipiv, const double* anorm, double* rcond, + void* work, fortran_int_t* info ); + +// Value-type variants of hprfs +void LAPACK_CHPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const void* afp, + const fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZHPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const void* afp, + const fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of hptrf +void LAPACK_CHPTRF( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_ZHPTRF( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* ipiv, fortran_int_t* info ); + +// Value-type variants of hptri +void LAPACK_CHPTRI( const char* uplo, const fortran_int_t* n, void* ap, + const fortran_int_t* ipiv, void* work, fortran_int_t* info ); +void LAPACK_ZHPTRI( const char* uplo, const fortran_int_t* n, void* ap, + const fortran_int_t* ipiv, void* work, fortran_int_t* info ); + +// Value-type variants of hptrs +void LAPACK_CHPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const fortran_int_t* ipiv, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZHPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const fortran_int_t* ipiv, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of pbcon +void LAPACK_SPBCON( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const float* ab, const fortran_int_t* ldab, + const float* anorm, float* rcond, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DPBCON( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const double* ab, const fortran_int_t* ldab, + const double* anorm, double* rcond, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPBCON( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const void* ab, const fortran_int_t* ldab, + const float* anorm, float* rcond, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZPBCON( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const void* ab, const fortran_int_t* ldab, + const double* anorm, double* rcond, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of pbequ +void LAPACK_SPBEQU( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const float* ab, const fortran_int_t* ldab, + float* s, float* scond, float* amax, fortran_int_t* info ); +void LAPACK_DPBEQU( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const double* ab, const fortran_int_t* ldab, + double* s, double* scond, double* amax, fortran_int_t* info ); +void LAPACK_CPBEQU( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const void* ab, const fortran_int_t* ldab, + float* s, float* scond, float* amax, fortran_int_t* info ); +void LAPACK_ZPBEQU( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const void* ab, const fortran_int_t* ldab, + double* s, double* scond, double* amax, fortran_int_t* info ); + +// Value-type variants of pbrfs +void LAPACK_SPBRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const float* ab, + const fortran_int_t* ldab, const float* afb, + const fortran_int_t* ldafb, const float* b, const fortran_int_t* ldb, + float* x, const fortran_int_t* ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DPBRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const double* ab, + const fortran_int_t* ldab, const double* afb, + const fortran_int_t* ldafb, const double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPBRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const void* ab, + const fortran_int_t* ldab, const void* afb, + const fortran_int_t* ldafb, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZPBRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const void* ab, + const fortran_int_t* ldab, const void* afb, + const fortran_int_t* ldafb, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of pbtrf +void LAPACK_SPBTRF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, float* ab, const fortran_int_t* ldab, + fortran_int_t* info ); +void LAPACK_DPBTRF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, double* ab, const fortran_int_t* ldab, + fortran_int_t* info ); +void LAPACK_CPBTRF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, void* ab, const fortran_int_t* ldab, + fortran_int_t* info ); +void LAPACK_ZPBTRF( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, void* ab, const fortran_int_t* ldab, + fortran_int_t* info ); + +// Value-type variants of pbtrs +void LAPACK_SPBTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const float* ab, + const fortran_int_t* ldab, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DPBTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const double* ab, + const fortran_int_t* ldab, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CPBTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const void* ab, + const fortran_int_t* ldab, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZPBTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, const void* ab, + const fortran_int_t* ldab, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of pftrf +void LAPACK_SPFTRF( const char* transr, const char* uplo, + const fortran_int_t* n, float* a, fortran_int_t* info ); +void LAPACK_DPFTRF( const char* transr, const char* uplo, + const fortran_int_t* n, double* a, fortran_int_t* info ); +void LAPACK_CPFTRF( const char* transr, const char* uplo, + const fortran_int_t* n, void* a, fortran_int_t* info ); +void LAPACK_ZPFTRF( const char* transr, const char* uplo, + const fortran_int_t* n, void* a, fortran_int_t* info ); + +// Value-type variants of pftri +void LAPACK_SPFTRI( const char* transr, const char* uplo, + const fortran_int_t* n, float* a, fortran_int_t* info ); +void LAPACK_DPFTRI( const char* transr, const char* uplo, + const fortran_int_t* n, double* a, fortran_int_t* info ); +void LAPACK_CPFTRI( const char* transr, const char* uplo, + const fortran_int_t* n, void* a, fortran_int_t* info ); +void LAPACK_ZPFTRI( const char* transr, const char* uplo, + const fortran_int_t* n, void* a, fortran_int_t* info ); + +// Value-type variants of pftrs +void LAPACK_SPFTRS( const char* transr, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* a, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DPFTRS( const char* transr, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* a, + double* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CPFTRS( const char* transr, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZPFTRS( const char* transr, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of pocon +void LAPACK_SPOCON( const char* uplo, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, const float* anorm, float* rcond, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DPOCON( const char* uplo, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, const double* anorm, double* rcond, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPOCON( const char* uplo, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const float* anorm, float* rcond, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZPOCON( const char* uplo, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const double* anorm, double* rcond, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of poequ +void LAPACK_SPOEQU( const fortran_int_t* n, const float* a, + const fortran_int_t* lda, float* s, float* scond, float* amax, + fortran_int_t* info ); +void LAPACK_DPOEQU( const fortran_int_t* n, const double* a, + const fortran_int_t* lda, double* s, double* scond, double* amax, + fortran_int_t* info ); +void LAPACK_CPOEQU( const fortran_int_t* n, const void* a, + const fortran_int_t* lda, float* s, float* scond, float* amax, + fortran_int_t* info ); +void LAPACK_ZPOEQU( const fortran_int_t* n, const void* a, + const fortran_int_t* lda, double* s, double* scond, double* amax, + fortran_int_t* info ); + +// Value-type variants of porfs +void LAPACK_SPORFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* a, const fortran_int_t* lda, + const float* af, const fortran_int_t* ldaf, const float* b, + const fortran_int_t* ldb, float* x, const fortran_int_t* ldx, + float* ferr, float* berr, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DPORFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* a, const fortran_int_t* lda, + const double* af, const fortran_int_t* ldaf, const double* b, + const fortran_int_t* ldb, double* x, const fortran_int_t* ldx, + double* ferr, double* berr, double* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CPORFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZPORFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of potrf +void LAPACK_SPOTRF( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* info ); +void LAPACK_DPOTRF( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* info ); +void LAPACK_CPOTRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* info ); +void LAPACK_ZPOTRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* info ); + +// Value-type variants of potri +void LAPACK_SPOTRI( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* info ); +void LAPACK_DPOTRI( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* info ); +void LAPACK_CPOTRI( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* info ); +void LAPACK_ZPOTRI( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* info ); + +// Value-type variants of potrs +void LAPACK_SPOTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DPOTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CPOTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZPOTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of ppcon +void LAPACK_SPPCON( const char* uplo, const fortran_int_t* n, const float* ap, + const float* anorm, float* rcond, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DPPCON( const char* uplo, const fortran_int_t* n, + const double* ap, const double* anorm, double* rcond, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPPCON( const char* uplo, const fortran_int_t* n, const void* ap, + const float* anorm, float* rcond, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZPPCON( const char* uplo, const fortran_int_t* n, const void* ap, + const double* anorm, double* rcond, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of ppequ +void LAPACK_SPPEQU( const char* uplo, const fortran_int_t* n, const float* ap, + float* s, float* scond, float* amax, fortran_int_t* info ); +void LAPACK_DPPEQU( const char* uplo, const fortran_int_t* n, + const double* ap, double* s, double* scond, double* amax, + fortran_int_t* info ); +void LAPACK_CPPEQU( const char* uplo, const fortran_int_t* n, const void* ap, + float* s, float* scond, float* amax, fortran_int_t* info ); +void LAPACK_ZPPEQU( const char* uplo, const fortran_int_t* n, const void* ap, + double* s, double* scond, double* amax, fortran_int_t* info ); + +// Value-type variants of pprfs +void LAPACK_SPPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* ap, const float* afp, + const float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DPPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* ap, const double* afp, + const double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const void* afp, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* ferr, float* berr, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZPPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const void* afp, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* ferr, double* berr, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of pptrf +void LAPACK_SPPTRF( const char* uplo, const fortran_int_t* n, float* ap, + fortran_int_t* info ); +void LAPACK_DPPTRF( const char* uplo, const fortran_int_t* n, double* ap, + fortran_int_t* info ); +void LAPACK_CPPTRF( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* info ); +void LAPACK_ZPPTRF( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* info ); + +// Value-type variants of pptri +void LAPACK_SPPTRI( const char* uplo, const fortran_int_t* n, float* ap, + fortran_int_t* info ); +void LAPACK_DPPTRI( const char* uplo, const fortran_int_t* n, double* ap, + fortran_int_t* info ); +void LAPACK_CPPTRI( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* info ); +void LAPACK_ZPPTRI( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* info ); + +// Value-type variants of pptrs +void LAPACK_SPPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* ap, float* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DPPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* ap, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CPPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZPPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of pstrf +void LAPACK_SPSTRF( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* piv, fortran_int_t* rank, + const float* tol, float* work, fortran_int_t* info ); +void LAPACK_DPSTRF( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* piv, fortran_int_t* rank, + const double* tol, double* work, fortran_int_t* info ); +void LAPACK_CPSTRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* piv, fortran_int_t* rank, + const float* tol, float* work, fortran_int_t* info ); +void LAPACK_ZPSTRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* piv, fortran_int_t* rank, + const double* tol, double* work, fortran_int_t* info ); + +// Value-type variants of ptcon +void LAPACK_SPTCON( const fortran_int_t* n, const float* d, const float* e, + const float* anorm, float* rcond, float* work, fortran_int_t* info ); +void LAPACK_DPTCON( const fortran_int_t* n, const double* d, const double* e, + const double* anorm, double* rcond, double* work, + fortran_int_t* info ); +void LAPACK_CPTCON( const fortran_int_t* n, const float* d, const void* e, + const float* anorm, float* rcond, float* rwork, fortran_int_t* info ); +void LAPACK_ZPTCON( const fortran_int_t* n, const double* d, const void* e, + const double* anorm, double* rcond, double* rwork, + fortran_int_t* info ); + +// Value-type variants of ptrfs +void LAPACK_SPTRFS( const fortran_int_t* n, const fortran_int_t* nrhs, + const float* d, const float* e, const float* df, const float* ef, + const float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* ferr, float* berr, float* work, + fortran_int_t* info ); +void LAPACK_DPTRFS( const fortran_int_t* n, const fortran_int_t* nrhs, + const double* d, const double* e, const double* df, const double* ef, + const double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* ferr, double* berr, double* work, + fortran_int_t* info ); +void LAPACK_CPTRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* d, const void* e, + const float* df, const void* ef, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZPTRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* d, const void* e, + const double* df, const void* ef, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of pttrf +void LAPACK_SPTTRF( const fortran_int_t* n, float* d, float* e, + fortran_int_t* info ); +void LAPACK_DPTTRF( const fortran_int_t* n, double* d, double* e, + fortran_int_t* info ); +void LAPACK_CPTTRF( const fortran_int_t* n, float* d, void* e, + fortran_int_t* info ); +void LAPACK_ZPTTRF( const fortran_int_t* n, double* d, void* e, + fortran_int_t* info ); + +// Value-type variants of pttrs +void LAPACK_SPTTRS( const fortran_int_t* n, const fortran_int_t* nrhs, + const float* d, const float* e, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DPTTRS( const fortran_int_t* n, const fortran_int_t* nrhs, + const double* d, const double* e, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CPTTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* d, const void* e, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZPTTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* d, const void* e, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of spcon +void LAPACK_SSPCON( const char* uplo, const fortran_int_t* n, const float* ap, + const fortran_int_t* ipiv, const float* anorm, float* rcond, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DSPCON( const char* uplo, const fortran_int_t* n, + const double* ap, const fortran_int_t* ipiv, const double* anorm, + double* rcond, double* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CSPCON( const char* uplo, const fortran_int_t* n, const void* ap, + const fortran_int_t* ipiv, const float* anorm, float* rcond, + void* work, fortran_int_t* info ); +void LAPACK_ZSPCON( const char* uplo, const fortran_int_t* n, const void* ap, + const fortran_int_t* ipiv, const double* anorm, double* rcond, + void* work, fortran_int_t* info ); + +// Value-type variants of sprfs +void LAPACK_SSPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* ap, const float* afp, + const fortran_int_t* ipiv, const float* b, const fortran_int_t* ldb, + float* x, const fortran_int_t* ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DSPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* ap, const double* afp, + const fortran_int_t* ipiv, const double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CSPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const void* afp, + const fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZSPRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const void* afp, + const fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of sptrf +void LAPACK_SSPTRF( const char* uplo, const fortran_int_t* n, float* ap, + fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_DSPTRF( const char* uplo, const fortran_int_t* n, double* ap, + fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_CSPTRF( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* ipiv, fortran_int_t* info ); +void LAPACK_ZSPTRF( const char* uplo, const fortran_int_t* n, void* ap, + fortran_int_t* ipiv, fortran_int_t* info ); + +// Value-type variants of sptri +void LAPACK_SSPTRI( const char* uplo, const fortran_int_t* n, float* ap, + const fortran_int_t* ipiv, float* work, fortran_int_t* info ); +void LAPACK_DSPTRI( const char* uplo, const fortran_int_t* n, double* ap, + const fortran_int_t* ipiv, double* work, fortran_int_t* info ); +void LAPACK_CSPTRI( const char* uplo, const fortran_int_t* n, void* ap, + const fortran_int_t* ipiv, void* work, fortran_int_t* info ); +void LAPACK_ZSPTRI( const char* uplo, const fortran_int_t* n, void* ap, + const fortran_int_t* ipiv, void* work, fortran_int_t* info ); + +// Value-type variants of sptrs +void LAPACK_SSPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* ap, const fortran_int_t* ipiv, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DSPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* ap, + const fortran_int_t* ipiv, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CSPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const fortran_int_t* ipiv, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZSPTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* ap, const fortran_int_t* ipiv, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of sycon +void LAPACK_SSYCON( const char* uplo, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, + const float* anorm, float* rcond, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DSYCON( const char* uplo, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, + const double* anorm, double* rcond, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CSYCON( const char* uplo, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, + const float* anorm, float* rcond, void* work, fortran_int_t* info ); +void LAPACK_ZSYCON( const char* uplo, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, + const double* anorm, double* rcond, void* work, fortran_int_t* info ); + +// Value-type variants of syrfs +void LAPACK_SSYRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* a, const fortran_int_t* lda, + const float* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DSYRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* a, const fortran_int_t* lda, + const double* af, const fortran_int_t* ldaf, + const fortran_int_t* ipiv, const double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CSYRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* ferr, float* berr, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZSYRFS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const void* af, const fortran_int_t* ldaf, const fortran_int_t* ipiv, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* ferr, double* berr, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of sytrf +void LAPACK_SSYTRF( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* ipiv, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DSYTRF( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* ipiv, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CSYTRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZSYTRF( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of sytri +void LAPACK_SSYTRI( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, float* work, + fortran_int_t* info ); +void LAPACK_DSYTRI( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, double* work, + fortran_int_t* info ); +void LAPACK_CSYTRI( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, void* work, + fortran_int_t* info ); +void LAPACK_ZSYTRI( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, const fortran_int_t* ipiv, void* work, + fortran_int_t* info ); + +// Value-type variants of sytrs +void LAPACK_SSYTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DSYTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CSYTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZSYTRS( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + const fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of tbcon +void LAPACK_STBCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, const float* ab, + const fortran_int_t* ldab, float* rcond, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DTBCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, const double* ab, + const fortran_int_t* ldab, double* rcond, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CTBCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, const void* ab, + const fortran_int_t* ldab, float* rcond, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZTBCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, const void* ab, + const fortran_int_t* ldab, double* rcond, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of tbrfs +void LAPACK_STBRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const float* ab, const fortran_int_t* ldab, + const float* b, const fortran_int_t* ldb, const float* x, + const fortran_int_t* ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DTBRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const double* ab, + const fortran_int_t* ldab, const double* b, const fortran_int_t* ldb, + const double* x, const fortran_int_t* ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CTBRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + const void* b, const fortran_int_t* ldb, const void* x, + const fortran_int_t* ldx, float* ferr, float* berr, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZTBRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + const void* b, const fortran_int_t* ldb, const void* x, + const fortran_int_t* ldx, double* ferr, double* berr, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of tbtrs +void LAPACK_STBTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const float* ab, const fortran_int_t* ldab, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DTBTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const double* ab, + const fortran_int_t* ldab, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CTBTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZTBTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, const void* ab, const fortran_int_t* ldab, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of tftri +void LAPACK_STFTRI( const char* transr, const char* uplo, const char* diag, + const fortran_int_t* n, float* a, fortran_int_t* info ); +void LAPACK_DTFTRI( const char* transr, const char* uplo, const char* diag, + const fortran_int_t* n, double* a, fortran_int_t* info ); +void LAPACK_CTFTRI( const char* transr, const char* uplo, const char* diag, + const fortran_int_t* n, void* a, fortran_int_t* info ); +void LAPACK_ZTFTRI( const char* transr, const char* uplo, const char* diag, + const fortran_int_t* n, void* a, fortran_int_t* info ); + +// Value-type variants of tpcon +void LAPACK_STPCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const float* ap, float* rcond, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DTPCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const double* ap, double* rcond, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CTPCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const void* ap, float* rcond, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZTPCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const void* ap, double* rcond, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of tprfs +void LAPACK_STPRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* ap, + const float* b, const fortran_int_t* ldb, const float* x, + const fortran_int_t* ldx, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DTPRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* ap, + const double* b, const fortran_int_t* ldb, const double* x, + const fortran_int_t* ldx, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CTPRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + const void* b, const fortran_int_t* ldb, const void* x, + const fortran_int_t* ldx, float* ferr, float* berr, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZTPRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + const void* b, const fortran_int_t* ldb, const void* x, + const fortran_int_t* ldx, double* ferr, double* berr, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of tptri +void LAPACK_STPTRI( const char* uplo, const char* diag, + const fortran_int_t* n, float* ap, fortran_int_t* info ); +void LAPACK_DTPTRI( const char* uplo, const char* diag, + const fortran_int_t* n, double* ap, fortran_int_t* info ); +void LAPACK_CTPTRI( const char* uplo, const char* diag, + const fortran_int_t* n, void* ap, fortran_int_t* info ); +void LAPACK_ZTPTRI( const char* uplo, const char* diag, + const fortran_int_t* n, void* ap, fortran_int_t* info ); + +// Value-type variants of tptrs +void LAPACK_STPTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* ap, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DTPTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* ap, + double* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CTPTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZTPTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + void* b, const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of trcon +void LAPACK_STRCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const float* a, const fortran_int_t* lda, + float* rcond, float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DTRCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const double* a, const fortran_int_t* lda, + double* rcond, double* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CTRCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + float* rcond, void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZTRCON( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + double* rcond, void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of trrfs +void LAPACK_STRRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* a, + const fortran_int_t* lda, const float* b, const fortran_int_t* ldb, + const float* x, const fortran_int_t* ldx, float* ferr, float* berr, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DTRRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* a, + const fortran_int_t* lda, const double* b, const fortran_int_t* ldb, + const double* x, const fortran_int_t* ldx, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CTRRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* x, const fortran_int_t* ldx, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZTRRFS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* x, const fortran_int_t* ldx, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of trtri +void LAPACK_STRTRI( const char* uplo, const char* diag, + const fortran_int_t* n, float* a, const fortran_int_t* lda, + fortran_int_t* info ); +void LAPACK_DTRTRI( const char* uplo, const char* diag, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + fortran_int_t* info ); +void LAPACK_CTRTRI( const char* uplo, const char* diag, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + fortran_int_t* info ); +void LAPACK_ZTRTRI( const char* uplo, const char* diag, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + fortran_int_t* info ); + +// Value-type variants of trtrs +void LAPACK_STRTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DTRTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CTRTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZTRTRS( const char* uplo, const char* trans, const char* diag, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of hbtrd +void LAPACK_CHBTRD( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, void* ab, + const fortran_int_t* ldab, float* d, float* e, void* q, + const fortran_int_t* ldq, void* work, fortran_int_t* info ); +void LAPACK_ZHBTRD( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, void* ab, + const fortran_int_t* ldab, double* d, double* e, void* q, + const fortran_int_t* ldq, void* work, fortran_int_t* info ); + +// Value-type variants of hetrd +void LAPACK_CHETRD( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, float* d, float* e, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZHETRD( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, double* d, double* e, void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of hptrd +void LAPACK_CHPTRD( const char* uplo, const fortran_int_t* n, void* ap, + float* d, float* e, void* tau, fortran_int_t* info ); +void LAPACK_ZHPTRD( const char* uplo, const fortran_int_t* n, void* ap, + double* d, double* e, void* tau, fortran_int_t* info ); + +// Value-type variants of opgtr +void LAPACK_SOPGTR( const char* uplo, const fortran_int_t* n, const float* ap, + const float* tau, float* q, const fortran_int_t* ldq, float* work, + fortran_int_t* info ); +void LAPACK_DOPGTR( const char* uplo, const fortran_int_t* n, + const double* ap, const double* tau, double* q, + const fortran_int_t* ldq, double* work, fortran_int_t* info ); + +// Value-type variants of opmtr +void LAPACK_SOPMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const float* ap, + const float* tau, float* c, const fortran_int_t* ldc, float* work, + fortran_int_t* info ); +void LAPACK_DOPMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const double* ap, + const double* tau, double* c, const fortran_int_t* ldc, double* work, + fortran_int_t* info ); + +// Value-type variants of orgtr +void LAPACK_SORGTR( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, const float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DORGTR( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, const double* tau, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ormtr +void LAPACK_SORMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, const float* tau, float* c, + const fortran_int_t* ldc, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DORMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, const double* tau, double* c, + const fortran_int_t* ldc, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of pteqr +void LAPACK_SPTEQR( const char* compz, const fortran_int_t* n, float* d, + float* e, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DPTEQR( const char* compz, const fortran_int_t* n, double* d, + double* e, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); +void LAPACK_CPTEQR( const char* compz, const fortran_int_t* n, float* d, + float* e, void* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_ZPTEQR( const char* compz, const fortran_int_t* n, double* d, + double* e, void* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); + +// Value-type variants of sbtrd +void LAPACK_SSBTRD( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, float* ab, + const fortran_int_t* ldab, float* d, float* e, float* q, + const fortran_int_t* ldq, float* work, fortran_int_t* info ); +void LAPACK_DSBTRD( const char* vect, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, double* ab, + const fortran_int_t* ldab, double* d, double* e, double* q, + const fortran_int_t* ldq, double* work, fortran_int_t* info ); + +// Value-type variants of sptrd +void LAPACK_SSPTRD( const char* uplo, const fortran_int_t* n, float* ap, + float* d, float* e, float* tau, fortran_int_t* info ); +void LAPACK_DSPTRD( const char* uplo, const fortran_int_t* n, double* ap, + double* d, double* e, double* tau, fortran_int_t* info ); + +// Value-type variants of stebz +void LAPACK_SSTEBZ( const char* range, const char* order, + const fortran_int_t* n, const float* vl, const float* vu, + const fortran_int_t* il, const fortran_int_t* iu, const float* abstol, + const float* d, const float* e, fortran_int_t* m, + fortran_int_t* nsplit, float* w, fortran_int_t* iblock, + fortran_int_t* isplit, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DSTEBZ( const char* range, const char* order, + const fortran_int_t* n, const double* vl, const double* vu, + const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, const double* d, const double* e, + fortran_int_t* m, fortran_int_t* nsplit, double* w, + fortran_int_t* iblock, fortran_int_t* isplit, double* work, + fortran_int_t* iwork, fortran_int_t* info ); + +// Value-type variants of stedc +void LAPACK_SSTEDC( const char* compz, const fortran_int_t* n, float* d, + float* e, float* z, const fortran_int_t* ldz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSTEDC( const char* compz, const fortran_int_t* n, double* d, + double* e, double* z, const fortran_int_t* ldz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_CSTEDC( const char* compz, const fortran_int_t* n, float* d, + float* e, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, float* rwork, const fortran_int_t* lrwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_ZSTEDC( const char* compz, const fortran_int_t* n, double* d, + double* e, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, double* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of stegr +void LAPACK_SSTEGR( const char* jobz, const char* range, + const fortran_int_t* n, float* d, float* e, const float* vl, + const float* vu, const fortran_int_t* il, const fortran_int_t* iu, + const float* abstol, fortran_int_t* m, float* w, float* z, + const fortran_int_t* ldz, fortran_int_t* isuppz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSTEGR( const char* jobz, const char* range, + const fortran_int_t* n, double* d, double* e, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, fortran_int_t* isuppz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_CSTEGR( const char* jobz, const char* range, + const fortran_int_t* n, float* d, float* e, const float* vl, + const float* vu, const fortran_int_t* il, const fortran_int_t* iu, + const float* abstol, fortran_int_t* m, float* w, void* z, + const fortran_int_t* ldz, fortran_int_t* isuppz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZSTEGR( const char* jobz, const char* range, + const fortran_int_t* n, double* d, double* e, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, void* z, + const fortran_int_t* ldz, fortran_int_t* isuppz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of stein +void LAPACK_SSTEIN( const fortran_int_t* n, const float* d, const float* e, + const fortran_int_t* m, const float* w, const fortran_int_t* iblock, + const fortran_int_t* isplit, float* z, const fortran_int_t* ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_DSTEIN( const fortran_int_t* n, const double* d, const double* e, + const fortran_int_t* m, const double* w, const fortran_int_t* iblock, + const fortran_int_t* isplit, double* z, const fortran_int_t* ldz, + double* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_CSTEIN( const fortran_int_t* n, const float* d, const float* e, + const fortran_int_t* m, const float* w, const fortran_int_t* iblock, + const fortran_int_t* isplit, void* z, const fortran_int_t* ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_ZSTEIN( const fortran_int_t* n, const double* d, const double* e, + const fortran_int_t* m, const double* w, const fortran_int_t* iblock, + const fortran_int_t* isplit, void* z, const fortran_int_t* ldz, + double* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); + +// Value-type variants of stemr +void LAPACK_SSTEMR( const char* jobz, const char* range, + const fortran_int_t* n, float* d, float* e, const float* vl, + const float* vu, const fortran_int_t* il, const fortran_int_t* iu, + fortran_int_t* m, float* w, float* z, const fortran_int_t* ldz, + const fortran_int_t* nzc, fortran_int_t* isuppz, + fortran_bool_t* tryrac, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_DSTEMR( const char* jobz, const char* range, + const fortran_int_t* n, double* d, double* e, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + fortran_int_t* m, double* w, double* z, const fortran_int_t* ldz, + const fortran_int_t* nzc, fortran_int_t* isuppz, + fortran_bool_t* tryrac, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_CSTEMR( const char* jobz, const char* range, + const fortran_int_t* n, float* d, float* e, const float* vl, + const float* vu, const fortran_int_t* il, const fortran_int_t* iu, + fortran_int_t* m, float* w, void* z, const fortran_int_t* ldz, + const fortran_int_t* nzc, fortran_int_t* isuppz, + fortran_bool_t* tryrac, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_ZSTEMR( const char* jobz, const char* range, + const fortran_int_t* n, double* d, double* e, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + fortran_int_t* m, double* w, void* z, const fortran_int_t* ldz, + const fortran_int_t* nzc, fortran_int_t* isuppz, + fortran_bool_t* tryrac, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); + +// Value-type variants of steqr +void LAPACK_SSTEQR( const char* compz, const fortran_int_t* n, float* d, + float* e, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DSTEQR( const char* compz, const fortran_int_t* n, double* d, + double* e, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); +void LAPACK_CSTEQR( const char* compz, const fortran_int_t* n, float* d, + float* e, void* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_ZSTEQR( const char* compz, const fortran_int_t* n, double* d, + double* e, void* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); + +// Value-type variants of sterf +void LAPACK_SSTERF( const fortran_int_t* n, float* d, float* e, + fortran_int_t* info ); +void LAPACK_DSTERF( const fortran_int_t* n, double* d, double* e, + fortran_int_t* info ); + +// Value-type variants of sytrd +void LAPACK_SSYTRD( const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* d, float* e, float* tau, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DSYTRD( const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* d, double* e, double* tau, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of ungtr +void LAPACK_CUNGTR( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, const void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZUNGTR( const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, const void* tau, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of unmtr +void LAPACK_CUNMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const void* tau, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_ZUNMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const void* tau, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of upgtr +void LAPACK_CUPGTR( const char* uplo, const fortran_int_t* n, const void* ap, + const void* tau, void* q, const fortran_int_t* ldq, void* work, + fortran_int_t* info ); +void LAPACK_ZUPGTR( const char* uplo, const fortran_int_t* n, const void* ap, + const void* tau, void* q, const fortran_int_t* ldq, void* work, + fortran_int_t* info ); + +// Value-type variants of upmtr +void LAPACK_CUPMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const void* ap, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + fortran_int_t* info ); +void LAPACK_ZUPMTR( const char* side, const char* uplo, const char* trans, + const fortran_int_t* m, const fortran_int_t* n, const void* ap, + const void* tau, void* c, const fortran_int_t* ldc, void* work, + fortran_int_t* info ); + +// Value-type variants of ggbak +void LAPACK_SGGBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const float* lscale, const float* rscale, const fortran_int_t* m, + float* v, const fortran_int_t* ldv, fortran_int_t* info ); +void LAPACK_DGGBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const double* lscale, const double* rscale, const fortran_int_t* m, + double* v, const fortran_int_t* ldv, fortran_int_t* info ); +void LAPACK_CGGBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const float* lscale, const float* rscale, const fortran_int_t* m, + void* v, const fortran_int_t* ldv, fortran_int_t* info ); +void LAPACK_ZGGBAK( const char* job, const char* side, const fortran_int_t* n, + const fortran_int_t* ilo, const fortran_int_t* ihi, + const double* lscale, const double* rscale, const fortran_int_t* m, + void* v, const fortran_int_t* ldv, fortran_int_t* info ); + +// Value-type variants of ggbal +void LAPACK_SGGBAL( const char* job, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + fortran_int_t* ilo, fortran_int_t* ihi, float* lscale, float* rscale, + float* work, fortran_int_t* info ); +void LAPACK_DGGBAL( const char* job, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + fortran_int_t* ilo, fortran_int_t* ihi, double* lscale, + double* rscale, double* work, fortran_int_t* info ); +void LAPACK_CGGBAL( const char* job, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* ilo, fortran_int_t* ihi, float* lscale, float* rscale, + float* work, fortran_int_t* info ); +void LAPACK_ZGGBAL( const char* job, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* ilo, fortran_int_t* ihi, double* lscale, + double* rscale, double* work, fortran_int_t* info ); + +// Value-type variants of gghrd +void LAPACK_SGGHRD( const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb, float* q, + const fortran_int_t* ldq, float* z, const fortran_int_t* ldz, + fortran_int_t* info ); +void LAPACK_DGGHRD( const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* q, + const fortran_int_t* ldq, double* z, const fortran_int_t* ldz, + fortran_int_t* info ); +void LAPACK_CGGHRD( const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* q, const fortran_int_t* ldq, void* z, + const fortran_int_t* ldz, fortran_int_t* info ); +void LAPACK_ZGGHRD( const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* q, const fortran_int_t* ldq, void* z, + const fortran_int_t* ldz, fortran_int_t* info ); + +// Value-type variants of hgeqz +void LAPACK_SHGEQZ( const char* job, const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, float* h, const fortran_int_t* ldh, + float* t, const fortran_int_t* ldt, float* alphar, float* alphai, + float* beta, float* q, const fortran_int_t* ldq, float* z, + const fortran_int_t* ldz, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DHGEQZ( const char* job, const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, double* h, const fortran_int_t* ldh, + double* t, const fortran_int_t* ldt, double* alphar, double* alphai, + double* beta, double* q, const fortran_int_t* ldq, double* z, + const fortran_int_t* ldz, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_CHGEQZ( const char* job, const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* h, const fortran_int_t* ldh, void* t, + const fortran_int_t* ldt, void* alpha, void* beta, void* q, + const fortran_int_t* ldq, void* z, const fortran_int_t* ldz, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHGEQZ( const char* job, const char* compq, const char* compz, + const fortran_int_t* n, const fortran_int_t* ilo, + const fortran_int_t* ihi, void* h, const fortran_int_t* ldh, void* t, + const fortran_int_t* ldt, void* alpha, void* beta, void* q, + const fortran_int_t* ldq, void* z, const fortran_int_t* ldz, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of tgevc +void LAPACK_STGEVC( const char* side, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const float* s, + const fortran_int_t* lds, const float* p, const fortran_int_t* ldp, + float* vl, const fortran_int_t* ldvl, float* vr, + const fortran_int_t* ldvr, const fortran_int_t* mm, fortran_int_t* m, + float* work, fortran_int_t* info ); +void LAPACK_DTGEVC( const char* side, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const double* s, + const fortran_int_t* lds, const double* p, const fortran_int_t* ldp, + double* vl, const fortran_int_t* ldvl, double* vr, + const fortran_int_t* ldvr, const fortran_int_t* mm, fortran_int_t* m, + double* work, fortran_int_t* info ); +void LAPACK_CTGEVC( const char* side, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const void* s, + const fortran_int_t* lds, const void* p, const fortran_int_t* ldp, + void* vl, const fortran_int_t* ldvl, void* vr, + const fortran_int_t* ldvr, const fortran_int_t* mm, fortran_int_t* m, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZTGEVC( const char* side, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const void* s, + const fortran_int_t* lds, const void* p, const fortran_int_t* ldp, + void* vl, const fortran_int_t* ldvl, void* vr, + const fortran_int_t* ldvr, const fortran_int_t* mm, fortran_int_t* m, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of tgexc +void LAPACK_STGEXC( const fortran_bool_t* wantq, const fortran_bool_t* wantz, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, float* q, const fortran_int_t* ldq, + float* z, const fortran_int_t* ldz, fortran_int_t* ifst, + fortran_int_t* ilst, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DTGEXC( const fortran_bool_t* wantq, const fortran_bool_t* wantz, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* q, + const fortran_int_t* ldq, double* z, const fortran_int_t* ldz, + fortran_int_t* ifst, fortran_int_t* ilst, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CTGEXC( const fortran_bool_t* wantq, const fortran_bool_t* wantz, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* q, const fortran_int_t* ldq, void* z, + const fortran_int_t* ldz, const fortran_int_t* ifst, + fortran_int_t* ilst, fortran_int_t* info ); +void LAPACK_ZTGEXC( const fortran_bool_t* wantq, const fortran_bool_t* wantz, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* q, const fortran_int_t* ldq, void* z, + const fortran_int_t* ldz, const fortran_int_t* ifst, + fortran_int_t* ilst, fortran_int_t* info ); + +// Value-type variants of tgsen +void LAPACK_STGSEN( const fortran_int_t* ijob, const fortran_bool_t* wantq, + const fortran_bool_t* wantz, const fortran_bool_t* select, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, float* alphar, float* alphai, float* beta, + float* q, const fortran_int_t* ldq, float* z, + const fortran_int_t* ldz, fortran_int_t* m, float* pl, float* pr, + float* dif, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_DTGSEN( const fortran_int_t* ijob, const fortran_bool_t* wantq, + const fortran_bool_t* wantz, const fortran_bool_t* select, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* alphar, double* alphai, + double* beta, double* q, const fortran_int_t* ldq, double* z, + const fortran_int_t* ldz, fortran_int_t* m, double* pl, double* pr, + double* dif, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_CTGSEN( const fortran_int_t* ijob, const fortran_bool_t* wantq, + const fortran_bool_t* wantz, const fortran_bool_t* select, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* alpha, void* beta, void* q, + const fortran_int_t* ldq, void* z, const fortran_int_t* ldz, + fortran_int_t* m, float* pl, float* pr, float* dif, void* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZTGSEN( const fortran_int_t* ijob, const fortran_bool_t* wantq, + const fortran_bool_t* wantz, const fortran_bool_t* select, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* alpha, void* beta, void* q, + const fortran_int_t* ldq, void* z, const fortran_int_t* ldz, + fortran_int_t* m, double* pl, double* pr, double* dif, void* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of tgsna +void LAPACK_STGSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, const float* b, const fortran_int_t* ldb, + const float* vl, const fortran_int_t* ldvl, const float* vr, + const fortran_int_t* ldvr, float* s, float* dif, + const fortran_int_t* mm, fortran_int_t* m, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DTGSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, const double* b, const fortran_int_t* ldb, + const double* vl, const fortran_int_t* ldvl, const double* vr, + const fortran_int_t* ldvr, double* s, double* dif, + const fortran_int_t* mm, fortran_int_t* m, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CTGSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* vl, const fortran_int_t* ldvl, const void* vr, + const fortran_int_t* ldvr, float* s, float* dif, + const fortran_int_t* mm, fortran_int_t* m, void* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_ZTGSNA( const char* job, const char* howmny, + const fortran_bool_t* select, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + const void* vl, const fortran_int_t* ldvl, const void* vr, + const fortran_int_t* ldvr, double* s, double* dif, + const fortran_int_t* mm, fortran_int_t* m, void* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of tgsyl +void LAPACK_STGSYL( const char* trans, const fortran_int_t* ijob, + const fortran_int_t* m, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, const float* b, const fortran_int_t* ldb, + float* c, const fortran_int_t* ldc, const float* d, + const fortran_int_t* ldd, const float* e, const fortran_int_t* lde, + float* f, const fortran_int_t* ldf, float* scale, float* dif, + float* work, const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DTGSYL( const char* trans, const fortran_int_t* ijob, + const fortran_int_t* m, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, const double* b, const fortran_int_t* ldb, + double* c, const fortran_int_t* ldc, const double* d, + const fortran_int_t* ldd, const double* e, const fortran_int_t* lde, + double* f, const fortran_int_t* ldf, double* scale, double* dif, + double* work, const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CTGSYL( const char* trans, const fortran_int_t* ijob, + const fortran_int_t* m, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + void* c, const fortran_int_t* ldc, const void* d, + const fortran_int_t* ldd, const void* e, const fortran_int_t* lde, + void* f, const fortran_int_t* ldf, float* scale, float* dif, + void* work, const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_ZTGSYL( const char* trans, const fortran_int_t* ijob, + const fortran_int_t* m, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, const void* b, const fortran_int_t* ldb, + void* c, const fortran_int_t* ldc, const void* d, + const fortran_int_t* ldd, const void* e, const fortran_int_t* lde, + void* f, const fortran_int_t* ldf, double* scale, double* dif, + void* work, const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of ggsvp +void LAPACK_SGGSVP( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, const float* tola, const float* tolb, + fortran_int_t* k, fortran_int_t* l, float* u, + const fortran_int_t* ldu, float* v, const fortran_int_t* ldv, + float* q, const fortran_int_t* ldq, fortran_int_t* iwork, float* tau, + float* work, fortran_int_t* info ); +void LAPACK_DGGSVP( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, const double* tola, + const double* tolb, fortran_int_t* k, fortran_int_t* l, double* u, + const fortran_int_t* ldu, double* v, const fortran_int_t* ldv, + double* q, const fortran_int_t* ldq, fortran_int_t* iwork, + double* tau, double* work, fortran_int_t* info ); +void LAPACK_CGGSVP( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, const float* tola, const float* tolb, + fortran_int_t* k, fortran_int_t* l, void* u, const fortran_int_t* ldu, + void* v, const fortran_int_t* ldv, void* q, const fortran_int_t* ldq, + fortran_int_t* iwork, float* rwork, void* tau, void* work, + fortran_int_t* info ); +void LAPACK_ZGGSVP( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, const double* tola, const double* tolb, + fortran_int_t* k, fortran_int_t* l, void* u, const fortran_int_t* ldu, + void* v, const fortran_int_t* ldv, void* q, const fortran_int_t* ldq, + fortran_int_t* iwork, double* rwork, void* tau, void* work, + fortran_int_t* info ); + +// Value-type variants of tgsja +void LAPACK_STGSJA( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, const fortran_int_t* k, + const fortran_int_t* l, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, const float* tola, const float* tolb, + float* alpha, float* beta, float* u, const fortran_int_t* ldu, + float* v, const fortran_int_t* ldv, float* q, + const fortran_int_t* ldq, float* work, fortran_int_t* ncycle, + fortran_int_t* info ); +void LAPACK_DTGSJA( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, const fortran_int_t* k, + const fortran_int_t* l, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, const double* tola, + const double* tolb, double* alpha, double* beta, double* u, + const fortran_int_t* ldu, double* v, const fortran_int_t* ldv, + double* q, const fortran_int_t* ldq, double* work, + fortran_int_t* ncycle, fortran_int_t* info ); +void LAPACK_CTGSJA( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, const fortran_int_t* k, + const fortran_int_t* l, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, const float* tola, const float* tolb, + float* alpha, float* beta, void* u, const fortran_int_t* ldu, void* v, + const fortran_int_t* ldv, void* q, const fortran_int_t* ldq, + void* work, fortran_int_t* ncycle, fortran_int_t* info ); +void LAPACK_ZTGSJA( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* p, + const fortran_int_t* n, const fortran_int_t* k, + const fortran_int_t* l, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, const double* tola, const double* tolb, + double* alpha, double* beta, void* u, const fortran_int_t* ldu, + void* v, const fortran_int_t* ldv, void* q, const fortran_int_t* ldq, + void* work, fortran_int_t* ncycle, fortran_int_t* info ); + +// +// LAPACK driver routines +// + +// Value-type variants of gegv +void LAPACK_SGEGV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, float* alphar, float* alphai, float* beta, + float* vl, const fortran_int_t* ldvl, float* vr, + const fortran_int_t* ldvr, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DGEGV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* alphar, double* alphai, + double* beta, double* vl, const fortran_int_t* ldvl, double* vr, + const fortran_int_t* ldvr, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_CGEGV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* alpha, void* beta, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGEGV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* alpha, void* beta, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gges +void LAPACK_SGGES( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + fortran_int_t* sdim, float* alphar, float* alphai, float* beta, + float* vsl, const fortran_int_t* ldvsl, float* vsr, + const fortran_int_t* ldvsr, float* work, const fortran_int_t* lwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_DGGES( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + fortran_int_t* sdim, double* alphar, double* alphai, double* beta, + double* vsl, const fortran_int_t* ldvsl, double* vsr, + const fortran_int_t* ldvsr, double* work, const fortran_int_t* lwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_CGGES( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* sdim, void* alpha, void* beta, void* vsl, + const fortran_int_t* ldvsl, void* vsr, const fortran_int_t* ldvsr, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_ZGGES( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* sdim, void* alpha, void* beta, void* vsl, + const fortran_int_t* ldvsl, void* vsr, const fortran_int_t* ldvsr, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_bool_t* bwork, fortran_int_t* info ); + +// Value-type variants of ggesx +void LAPACK_SGGESX( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const char* sense, const fortran_int_t* n, + float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, fortran_int_t* sdim, float* alphar, + float* alphai, float* beta, float* vsl, const fortran_int_t* ldvsl, + float* vsr, const fortran_int_t* ldvsr, float* rconde, float* rcondv, + float* work, const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_bool_t* bwork, + fortran_int_t* info ); +void LAPACK_DGGESX( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const char* sense, const fortran_int_t* n, + double* a, const fortran_int_t* lda, double* b, + const fortran_int_t* ldb, fortran_int_t* sdim, double* alphar, + double* alphai, double* beta, double* vsl, const fortran_int_t* ldvsl, + double* vsr, const fortran_int_t* ldvsr, double* rconde, + double* rcondv, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_CGGESX( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const char* sense, const fortran_int_t* n, + void* a, const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* sdim, void* alpha, void* beta, void* vsl, + const fortran_int_t* ldvsl, void* vsr, const fortran_int_t* ldvsr, + float* rconde, float* rcondv, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_ZGGESX( const char* jobvsl, const char* jobvsr, const char* sort, + external_fp selctg, const char* sense, const fortran_int_t* n, + void* a, const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + fortran_int_t* sdim, void* alpha, void* beta, void* vsl, + const fortran_int_t* ldvsl, void* vsr, const fortran_int_t* ldvsr, + double* rconde, double* rcondv, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_bool_t* bwork, + fortran_int_t* info ); + +// Value-type variants of ggev +void LAPACK_SGGEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, float* alphar, float* alphai, float* beta, + float* vl, const fortran_int_t* ldvl, float* vr, + const fortran_int_t* ldvr, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DGGEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* alphar, double* alphai, + double* beta, double* vl, const fortran_int_t* ldvl, double* vr, + const fortran_int_t* ldvr, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_CGGEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* alpha, void* beta, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGGEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* alpha, void* beta, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of ggevx +void LAPACK_SGGEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + float* alphar, float* alphai, float* beta, float* vl, + const fortran_int_t* ldvl, float* vr, const fortran_int_t* ldvr, + fortran_int_t* ilo, fortran_int_t* ihi, float* lscale, float* rscale, + float* abnrm, float* bbnrm, float* rconde, float* rcondv, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_DGGEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + double* alphar, double* alphai, double* beta, double* vl, + const fortran_int_t* ldvl, double* vr, const fortran_int_t* ldvr, + fortran_int_t* ilo, fortran_int_t* ihi, double* lscale, + double* rscale, double* abnrm, double* bbnrm, double* rconde, + double* rcondv, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_CGGEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + void* alpha, void* beta, void* vl, const fortran_int_t* ldvl, + void* vr, const fortran_int_t* ldvr, fortran_int_t* ilo, + fortran_int_t* ihi, float* lscale, float* rscale, float* abnrm, + float* bbnrm, float* rconde, float* rcondv, void* work, + const fortran_int_t* lwork, float* rwork, fortran_int_t* iwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_ZGGEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + void* alpha, void* beta, void* vl, const fortran_int_t* ldvl, + void* vr, const fortran_int_t* ldvr, fortran_int_t* ilo, + fortran_int_t* ihi, double* lscale, double* rscale, double* abnrm, + double* bbnrm, double* rconde, double* rcondv, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* iwork, + fortran_bool_t* bwork, fortran_int_t* info ); + +// Value-type variants of ggsvd +void LAPACK_SGGSVD( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, fortran_int_t* k, fortran_int_t* l, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + float* alpha, float* beta, float* u, const fortran_int_t* ldu, + float* v, const fortran_int_t* ldv, float* q, + const fortran_int_t* ldq, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DGGSVD( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, fortran_int_t* k, fortran_int_t* l, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + double* alpha, double* beta, double* u, const fortran_int_t* ldu, + double* v, const fortran_int_t* ldv, double* q, + const fortran_int_t* ldq, double* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CGGSVD( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, fortran_int_t* k, fortran_int_t* l, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + float* alpha, float* beta, void* u, const fortran_int_t* ldu, void* v, + const fortran_int_t* ldv, void* q, const fortran_int_t* ldq, + void* work, float* rwork, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_ZGGSVD( const char* jobu, const char* jobv, const char* jobq, + const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, fortran_int_t* k, fortran_int_t* l, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + double* alpha, double* beta, void* u, const fortran_int_t* ldu, + void* v, const fortran_int_t* ldv, void* q, const fortran_int_t* ldq, + void* work, double* rwork, fortran_int_t* iwork, fortran_int_t* info ); + +// Value-type variants of hbgv +void LAPACK_CHBGV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* ka, const fortran_int_t* kb, void* ab, + const fortran_int_t* ldab, void* bb, const fortran_int_t* ldbb, + float* w, void* z, const fortran_int_t* ldz, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHBGV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* ka, const fortran_int_t* kb, void* ab, + const fortran_int_t* ldab, void* bb, const fortran_int_t* ldbb, + double* w, void* z, const fortran_int_t* ldz, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of hbgvd +void LAPACK_CHBGVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, void* ab, const fortran_int_t* ldab, + void* bb, const fortran_int_t* ldbb, float* w, void* z, + const fortran_int_t* ldz, void* work, const fortran_int_t* lwork, + float* rwork, const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZHBGVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, void* ab, const fortran_int_t* ldab, + void* bb, const fortran_int_t* ldbb, double* w, void* z, + const fortran_int_t* ldz, void* work, const fortran_int_t* lwork, + double* rwork, const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of hbgvx +void LAPACK_CHBGVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, void* ab, const fortran_int_t* ldab, + void* bb, const fortran_int_t* ldbb, void* q, + const fortran_int_t* ldq, const float* vl, const float* vu, + const fortran_int_t* il, const fortran_int_t* iu, const float* abstol, + fortran_int_t* m, float* w, void* z, const fortran_int_t* ldz, + void* work, float* rwork, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_ZHBGVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, void* ab, const fortran_int_t* ldab, + void* bb, const fortran_int_t* ldbb, void* q, + const fortran_int_t* ldq, const double* vl, const double* vu, + const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, void* z, + const fortran_int_t* ldz, void* work, double* rwork, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of hegv +void LAPACK_CHEGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, float* w, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHEGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + double* w, void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of hegvd +void LAPACK_CHEGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, float* w, + void* work, const fortran_int_t* lwork, float* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZHEGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + double* w, void* work, const fortran_int_t* lwork, double* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of hegvx +void LAPACK_CHEGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_ZHEGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of hpgv +void LAPACK_CHPGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* ap, void* bp, + float* w, void* z, const fortran_int_t* ldz, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHPGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* ap, void* bp, + double* w, void* z, const fortran_int_t* ldz, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of hpgvd +void LAPACK_CHPGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* ap, void* bp, + float* w, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, float* rwork, const fortran_int_t* lrwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_ZHPGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, void* ap, void* bp, + double* w, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, double* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of hpgvx +void LAPACK_CHPGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, void* ap, + void* bp, const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, void* z, const fortran_int_t* ldz, void* work, float* rwork, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_ZHPGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, void* ap, + void* bp, const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, void* z, const fortran_int_t* ldz, void* work, + double* rwork, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); + +// Value-type variants of sbgv +void LAPACK_SSBGV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* ka, const fortran_int_t* kb, float* ab, + const fortran_int_t* ldab, float* bb, const fortran_int_t* ldbb, + float* w, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DSBGV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* ka, const fortran_int_t* kb, double* ab, + const fortran_int_t* ldab, double* bb, const fortran_int_t* ldbb, + double* w, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); + +// Value-type variants of sbgvd +void LAPACK_SSBGVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, float* ab, const fortran_int_t* ldab, + float* bb, const fortran_int_t* ldbb, float* w, float* z, + const fortran_int_t* ldz, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_DSBGVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, double* ab, const fortran_int_t* ldab, + double* bb, const fortran_int_t* ldbb, double* w, double* z, + const fortran_int_t* ldz, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); + +// Value-type variants of sbgvx +void LAPACK_SSBGVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, float* ab, const fortran_int_t* ldab, + float* bb, const fortran_int_t* ldbb, float* q, + const fortran_int_t* ldq, const float* vl, const float* vu, + const fortran_int_t* il, const fortran_int_t* iu, const float* abstol, + fortran_int_t* m, float* w, float* z, const fortran_int_t* ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_DSBGVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* ka, + const fortran_int_t* kb, double* ab, const fortran_int_t* ldab, + double* bb, const fortran_int_t* ldbb, double* q, + const fortran_int_t* ldq, const double* vl, const double* vu, + const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, double* work, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of spgv +void LAPACK_SSPGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, float* ap, float* bp, + float* w, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DSPGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, double* ap, double* bp, + double* w, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); + +// Value-type variants of spgvd +void LAPACK_SSPGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, float* ap, float* bp, + float* w, float* z, const fortran_int_t* ldz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSPGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, double* ap, double* bp, + double* w, double* z, const fortran_int_t* ldz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of spgvx +void LAPACK_SSPGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, + float* ap, float* bp, const float* vl, const float* vu, + const fortran_int_t* il, const fortran_int_t* iu, const float* abstol, + fortran_int_t* m, float* w, float* z, const fortran_int_t* ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_DSPGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, + double* ap, double* bp, const double* vl, const double* vu, + const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, double* work, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of sygv +void LAPACK_SSYGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + float* w, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DSYGV( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + double* w, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); + +// Value-type variants of sygvd +void LAPACK_SSYGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + float* w, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_DSYGVD( const fortran_int_t* itype, const char* jobz, + const char* uplo, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + double* w, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); + +// Value-type variants of sygvx +void LAPACK_SSYGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, float* z, const fortran_int_t* ldz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_DSYGVX( const fortran_int_t* itype, const char* jobz, + const char* range, const char* uplo, const fortran_int_t* n, + double* a, const fortran_int_t* lda, double* b, + const fortran_int_t* ldb, const double* vl, const double* vu, + const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of ggglm +void LAPACK_SGGGLM( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, float* d, float* x, float* y, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGGGLM( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* d, double* x, double* y, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGGGLM( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* d, void* x, void* y, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGGGLM( const fortran_int_t* n, const fortran_int_t* m, + const fortran_int_t* p, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* d, void* x, void* y, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of gglse +void LAPACK_SGGLSE( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, float* a, const fortran_int_t* lda, float* b, + const fortran_int_t* ldb, float* c, float* d, float* x, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGGLSE( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* c, double* d, double* x, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGGLSE( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* c, void* d, void* x, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGGLSE( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* p, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, void* c, void* d, void* x, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of gbsv +void LAPACK_SGBSV( const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, float* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, float* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DGBSV( const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, double* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CGBSV( const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, void* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZGBSV( const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, void* ab, + const fortran_int_t* ldab, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of gbsvx +void LAPACK_SGBSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, float* ab, + const fortran_int_t* ldab, float* afb, const fortran_int_t* ldafb, + fortran_int_t* ipiv, char* equed, float* r, float* c, float* b, + const fortran_int_t* ldb, float* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGBSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, double* ab, + const fortran_int_t* ldab, double* afb, const fortran_int_t* ldafb, + fortran_int_t* ipiv, char* equed, double* r, double* c, double* b, + const fortran_int_t* ldb, double* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGBSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, void* ab, + const fortran_int_t* ldab, void* afb, const fortran_int_t* ldafb, + fortran_int_t* ipiv, char* equed, float* r, float* c, void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGBSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* kl, + const fortran_int_t* ku, const fortran_int_t* nrhs, void* ab, + const fortran_int_t* ldab, void* afb, const fortran_int_t* ldafb, + fortran_int_t* ipiv, char* equed, double* r, double* c, void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gejsv +void LAPACK_SGEJSV( const char* joba, const char* jobu, const char* jobv, + const char* jobr, const char* jobt, const char* jobp, + const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* sva, float* u, + const fortran_int_t* ldu, float* v, const fortran_int_t* ldv, + float* work, const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DGEJSV( const char* joba, const char* jobu, const char* jobv, + const char* jobr, const char* jobt, const char* jobp, + const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* sva, double* u, + const fortran_int_t* ldu, double* v, const fortran_int_t* ldv, + double* work, const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of gesv +void LAPACK_SGESV( const fortran_int_t* n, const fortran_int_t* nrhs, + float* a, const fortran_int_t* lda, fortran_int_t* ipiv, float* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DGESV( const fortran_int_t* n, const fortran_int_t* nrhs, + double* a, const fortran_int_t* lda, fortran_int_t* ipiv, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CGESV( const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZGESV( const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of gesvx +void LAPACK_SGESVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, float* a, + const fortran_int_t* lda, float* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, char* equed, float* r, float* c, float* b, + const fortran_int_t* ldb, float* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGESVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, double* a, + const fortran_int_t* lda, double* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, char* equed, double* r, double* c, double* b, + const fortran_int_t* ldb, double* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGESVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, char* equed, float* r, float* c, void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGESVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, char* equed, double* r, double* c, void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gtsv +void LAPACK_SGTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + float* dl, float* d, float* du, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DGTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + double* dl, double* d, double* du, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CGTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + void* dl, void* d, void* du, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZGTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + void* dl, void* d, void* du, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of gtsvx +void LAPACK_SGTSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* dl, + const float* d, const float* du, float* dlf, float* df, float* duf, + float* du2, fortran_int_t* ipiv, const float* b, + const fortran_int_t* ldb, float* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGTSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* dl, + const double* d, const double* du, double* dlf, double* df, + double* duf, double* du2, fortran_int_t* ipiv, const double* b, + const fortran_int_t* ldb, double* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGTSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* dl, + const void* d, const void* du, void* dlf, void* df, void* duf, + void* du2, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZGTSVX( const char* fact, const char* trans, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* dl, + const void* d, const void* du, void* dlf, void* df, void* duf, + void* du2, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of hesv +void LAPACK_CHESV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, + fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZHESV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, + fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of hesvx +void LAPACK_CHESVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHESVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* rcond, double* ferr, double* berr, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of hpsv +void LAPACK_CHPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* ap, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZHPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* ap, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of hpsvx +void LAPACK_CHPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + void* afp, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + void* afp, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of iter_gesv +void LAPACK_DSGESV( const fortran_int_t* n, const fortran_int_t* nrhs, + double* a, const fortran_int_t* lda, fortran_int_t* ipiv, + const double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* work, float* swork, + fortran_int_t* iter, fortran_int_t* info ); +void LAPACK_ZCGESV( const fortran_int_t* n, const fortran_int_t* nrhs, + void* a, const fortran_int_t* lda, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + void* work, void* swork, double* rwork, fortran_int_t* iter, + fortran_int_t* info ); + +// Value-type variants of iter_posv +void LAPACK_DSPOSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, double* a, const fortran_int_t* lda, + const double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* work, float* swork, + fortran_int_t* iter, fortran_int_t* info ); +void LAPACK_ZCPOSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, + const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, void* work, void* swork, double* rwork, + fortran_int_t* iter, fortran_int_t* info ); + +// Value-type variants of pbsv +void LAPACK_SPBSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, float* ab, + const fortran_int_t* ldab, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DPBSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, double* ab, + const fortran_int_t* ldab, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CPBSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, void* ab, + const fortran_int_t* ldab, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZPBSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, const fortran_int_t* nrhs, void* ab, + const fortran_int_t* ldab, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of pbsvx +void LAPACK_SPBSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, float* ab, const fortran_int_t* ldab, + float* afb, const fortran_int_t* ldafb, char* equed, float* s, + float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DPBSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, double* ab, const fortran_int_t* ldab, + double* afb, const fortran_int_t* ldafb, char* equed, double* s, + double* b, const fortran_int_t* ldb, double* x, + const fortran_int_t* ldx, double* rcond, double* ferr, double* berr, + double* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPBSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, void* ab, const fortran_int_t* ldab, + void* afb, const fortran_int_t* ldafb, char* equed, float* s, void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZPBSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, + const fortran_int_t* nrhs, void* ab, const fortran_int_t* ldab, + void* afb, const fortran_int_t* ldafb, char* equed, double* s, + void* b, const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of posv +void LAPACK_SPOSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DPOSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CPOSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZPOSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of posvx +void LAPACK_SPOSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, float* a, + const fortran_int_t* lda, float* af, const fortran_int_t* ldaf, + char* equed, float* s, float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DPOSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, double* a, + const fortran_int_t* lda, double* af, const fortran_int_t* ldaf, + char* equed, double* s, double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* rcond, double* ferr, + double* berr, double* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CPOSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + char* equed, float* s, void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZPOSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + char* equed, double* s, void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* rcond, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of ppsv +void LAPACK_SPPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, float* ap, float* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DPPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, double* ap, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CPPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* ap, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZPPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* ap, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of ppsvx +void LAPACK_SPPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, float* ap, + float* afp, char* equed, float* s, float* b, const fortran_int_t* ldb, + float* x, const fortran_int_t* ldx, float* rcond, float* ferr, + float* berr, float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DPPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, double* ap, + double* afp, char* equed, double* s, double* b, + const fortran_int_t* ldb, double* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CPPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, void* ap, + void* afp, char* equed, float* s, void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, float* rcond, float* ferr, + float* berr, void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZPPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, void* ap, + void* afp, char* equed, double* s, void* b, const fortran_int_t* ldb, + void* x, const fortran_int_t* ldx, double* rcond, double* ferr, + double* berr, void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of ptsv +void LAPACK_SPTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + float* d, float* e, float* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_DPTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + double* d, double* e, double* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_CPTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + float* d, void* e, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); +void LAPACK_ZPTSV( const fortran_int_t* n, const fortran_int_t* nrhs, + double* d, void* e, void* b, const fortran_int_t* ldb, + fortran_int_t* info ); + +// Value-type variants of ptsvx +void LAPACK_SPTSVX( const char* fact, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* d, const float* e, float* df, + float* ef, const float* b, const fortran_int_t* ldb, float* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + float* work, fortran_int_t* info ); +void LAPACK_DPTSVX( const char* fact, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* d, const double* e, + double* df, double* ef, const double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* rcond, double* ferr, + double* berr, double* work, fortran_int_t* info ); +void LAPACK_CPTSVX( const char* fact, const fortran_int_t* n, + const fortran_int_t* nrhs, const float* d, const void* e, float* df, + void* ef, const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + void* work, float* rwork, fortran_int_t* info ); +void LAPACK_ZPTSVX( const char* fact, const fortran_int_t* n, + const fortran_int_t* nrhs, const double* d, const void* e, double* df, + void* ef, const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* rcond, double* ferr, double* berr, + void* work, double* rwork, fortran_int_t* info ); + +// Value-type variants of spsv +void LAPACK_SSPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, float* ap, fortran_int_t* ipiv, float* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_DSPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, double* ap, fortran_int_t* ipiv, double* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_CSPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* ap, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); +void LAPACK_ZSPSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* ap, fortran_int_t* ipiv, void* b, + const fortran_int_t* ldb, fortran_int_t* info ); + +// Value-type variants of spsvx +void LAPACK_SSPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* ap, + float* afp, fortran_int_t* ipiv, const float* b, + const fortran_int_t* ldb, float* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DSPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* ap, + double* afp, fortran_int_t* ipiv, const double* b, + const fortran_int_t* ldb, double* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CSPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + void* afp, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + float* rcond, float* ferr, float* berr, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZSPSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* ap, + void* afp, fortran_int_t* ipiv, const void* b, + const fortran_int_t* ldb, void* x, const fortran_int_t* ldx, + double* rcond, double* ferr, double* berr, void* work, double* rwork, + fortran_int_t* info ); + +// Value-type variants of sysv +void LAPACK_SSYSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, float* a, const fortran_int_t* lda, + fortran_int_t* ipiv, float* b, const fortran_int_t* ldb, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DSYSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, double* a, const fortran_int_t* lda, + fortran_int_t* ipiv, double* b, const fortran_int_t* ldb, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CSYSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, + fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZSYSV( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, + fortran_int_t* ipiv, void* b, const fortran_int_t* ldb, void* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of sysvx +void LAPACK_SSYSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const float* a, + const fortran_int_t* lda, float* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, const float* b, const fortran_int_t* ldb, + float* x, const fortran_int_t* ldx, float* rcond, float* ferr, + float* berr, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DSYSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const double* a, + const fortran_int_t* lda, double* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, const double* b, const fortran_int_t* ldb, + double* x, const fortran_int_t* ldx, double* rcond, double* ferr, + double* berr, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CSYSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, float* rcond, float* ferr, float* berr, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_int_t* info ); +void LAPACK_ZSYSVX( const char* fact, const char* uplo, + const fortran_int_t* n, const fortran_int_t* nrhs, const void* a, + const fortran_int_t* lda, void* af, const fortran_int_t* ldaf, + fortran_int_t* ipiv, const void* b, const fortran_int_t* ldb, void* x, + const fortran_int_t* ldx, double* rcond, double* ferr, double* berr, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of gees +void LAPACK_SGEES( const char* jobvs, const char* sort, external_fp select, + const fortran_int_t* n, float* a, const fortran_int_t* lda, + fortran_int_t* sdim, float* wr, float* wi, float* vs, + const fortran_int_t* ldvs, float* work, const fortran_int_t* lwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_DGEES( const char* jobvs, const char* sort, external_fp select, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + fortran_int_t* sdim, double* wr, double* wi, double* vs, + const fortran_int_t* ldvs, double* work, const fortran_int_t* lwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_CGEES( const char* jobvs, const char* sort, external_fp select, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + fortran_int_t* sdim, void* w, void* vs, const fortran_int_t* ldvs, + void* work, const fortran_int_t* lwork, float* rwork, + fortran_bool_t* bwork, fortran_int_t* info ); +void LAPACK_ZGEES( const char* jobvs, const char* sort, external_fp select, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + fortran_int_t* sdim, void* w, void* vs, const fortran_int_t* ldvs, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_bool_t* bwork, fortran_int_t* info ); + +// Value-type variants of geesx +void LAPACK_SGEESX( const char* jobvs, const char* sort, external_fp select, + const char* sense, const fortran_int_t* n, float* a, + const fortran_int_t* lda, fortran_int_t* sdim, float* wr, float* wi, + float* vs, const fortran_int_t* ldvs, float* rconde, float* rcondv, + float* work, const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_bool_t* bwork, + fortran_int_t* info ); +void LAPACK_DGEESX( const char* jobvs, const char* sort, external_fp select, + const char* sense, const fortran_int_t* n, double* a, + const fortran_int_t* lda, fortran_int_t* sdim, double* wr, double* wi, + double* vs, const fortran_int_t* ldvs, double* rconde, double* rcondv, + double* work, const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_bool_t* bwork, + fortran_int_t* info ); +void LAPACK_CGEESX( const char* jobvs, const char* sort, external_fp select, + const char* sense, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* sdim, void* w, void* vs, + const fortran_int_t* ldvs, float* rconde, float* rcondv, void* work, + const fortran_int_t* lwork, float* rwork, fortran_bool_t* bwork, + fortran_int_t* info ); +void LAPACK_ZGEESX( const char* jobvs, const char* sort, external_fp select, + const char* sense, const fortran_int_t* n, void* a, + const fortran_int_t* lda, fortran_int_t* sdim, void* w, void* vs, + const fortran_int_t* ldvs, double* rconde, double* rcondv, void* work, + const fortran_int_t* lwork, double* rwork, fortran_bool_t* bwork, + fortran_int_t* info ); + +// Value-type variants of geev +void LAPACK_SGEEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* wr, + float* wi, float* vl, const fortran_int_t* ldvl, float* vr, + const fortran_int_t* ldvr, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DGEEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* wr, double* wi, double* vl, const fortran_int_t* ldvl, + double* vr, const fortran_int_t* ldvr, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGEEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* w, + void* vl, const fortran_int_t* ldvl, void* vr, + const fortran_int_t* ldvr, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* info ); +void LAPACK_ZGEEV( const char* jobvl, const char* jobvr, + const fortran_int_t* n, void* a, const fortran_int_t* lda, void* w, + void* vl, const fortran_int_t* ldvl, void* vr, + const fortran_int_t* ldvr, void* work, const fortran_int_t* lwork, + double* rwork, fortran_int_t* info ); + +// Value-type variants of geevx +void LAPACK_SGEEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* wr, float* wi, float* vl, + const fortran_int_t* ldvl, float* vr, const fortran_int_t* ldvr, + fortran_int_t* ilo, fortran_int_t* ihi, float* scale, float* abnrm, + float* rconde, float* rcondv, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGEEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* wr, double* wi, double* vl, + const fortran_int_t* ldvl, double* vr, const fortran_int_t* ldvr, + fortran_int_t* ilo, fortran_int_t* ihi, double* scale, double* abnrm, + double* rconde, double* rcondv, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CGEEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* w, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + fortran_int_t* ilo, fortran_int_t* ihi, float* scale, float* abnrm, + float* rconde, float* rcondv, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* info ); +void LAPACK_ZGEEVX( const char* balanc, const char* jobvl, const char* jobvr, + const char* sense, const fortran_int_t* n, void* a, + const fortran_int_t* lda, void* w, void* vl, + const fortran_int_t* ldvl, void* vr, const fortran_int_t* ldvr, + fortran_int_t* ilo, fortran_int_t* ihi, double* scale, double* abnrm, + double* rconde, double* rcondv, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* info ); + +// Value-type variants of gesdd +void LAPACK_SGESDD( const char* jobz, const fortran_int_t* m, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* s, + float* u, const fortran_int_t* ldu, float* vt, + const fortran_int_t* ldvt, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGESDD( const char* jobz, const fortran_int_t* m, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* s, double* u, const fortran_int_t* ldu, double* vt, + const fortran_int_t* ldvt, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGESDD( const char* jobz, const fortran_int_t* m, + const fortran_int_t* n, void* a, const fortran_int_t* lda, float* s, + void* u, const fortran_int_t* ldu, void* vt, + const fortran_int_t* ldvt, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_ZGESDD( const char* jobz, const fortran_int_t* m, + const fortran_int_t* n, void* a, const fortran_int_t* lda, double* s, + void* u, const fortran_int_t* ldu, void* vt, + const fortran_int_t* ldvt, void* work, const fortran_int_t* lwork, + double* rwork, fortran_int_t* iwork, fortran_int_t* info ); + +// Value-type variants of gesvd +void LAPACK_SGESVD( const char* jobu, const char* jobvt, + const fortran_int_t* m, const fortran_int_t* n, float* a, + const fortran_int_t* lda, float* s, float* u, + const fortran_int_t* ldu, float* vt, const fortran_int_t* ldvt, + float* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGESVD( const char* jobu, const char* jobvt, + const fortran_int_t* m, const fortran_int_t* n, double* a, + const fortran_int_t* lda, double* s, double* u, + const fortran_int_t* ldu, double* vt, const fortran_int_t* ldvt, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGESVD( const char* jobu, const char* jobvt, + const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, float* s, void* u, const fortran_int_t* ldu, + void* vt, const fortran_int_t* ldvt, void* work, + const fortran_int_t* lwork, float* rwork, fortran_int_t* info ); +void LAPACK_ZGESVD( const char* jobu, const char* jobvt, + const fortran_int_t* m, const fortran_int_t* n, void* a, + const fortran_int_t* lda, double* s, void* u, + const fortran_int_t* ldu, void* vt, const fortran_int_t* ldvt, + void* work, const fortran_int_t* lwork, double* rwork, + fortran_int_t* info ); + +// Value-type variants of hbev +void LAPACK_CHBEV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, void* ab, const fortran_int_t* ldab, + float* w, void* z, const fortran_int_t* ldz, void* work, float* rwork, + fortran_int_t* info ); +void LAPACK_ZHBEV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, void* ab, const fortran_int_t* ldab, + double* w, void* z, const fortran_int_t* ldz, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of hbevd +void LAPACK_CHBEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, void* ab, + const fortran_int_t* ldab, float* w, void* z, + const fortran_int_t* ldz, void* work, const fortran_int_t* lwork, + float* rwork, const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZHBEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, void* ab, + const fortran_int_t* ldab, double* w, void* z, + const fortran_int_t* ldz, void* work, const fortran_int_t* lwork, + double* rwork, const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of hbevx +void LAPACK_CHBEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, void* ab, + const fortran_int_t* ldab, void* q, const fortran_int_t* ldq, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, void* z, const fortran_int_t* ldz, void* work, float* rwork, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_ZHBEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, void* ab, + const fortran_int_t* ldab, void* q, const fortran_int_t* ldq, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, void* z, const fortran_int_t* ldz, void* work, + double* rwork, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); + +// Value-type variants of heev +void LAPACK_CHEEV( const char* jobz, const char* uplo, const fortran_int_t* n, + void* a, const fortran_int_t* lda, float* w, void* work, + const fortran_int_t* lwork, float* rwork, fortran_int_t* info ); +void LAPACK_ZHEEV( const char* jobz, const char* uplo, const fortran_int_t* n, + void* a, const fortran_int_t* lda, double* w, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* info ); + +// Value-type variants of heevd +void LAPACK_CHEEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, float* w, + void* work, const fortran_int_t* lwork, float* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZHEEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, double* w, + void* work, const fortran_int_t* lwork, double* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of heevr +void LAPACK_CHEEVR( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, void* z, const fortran_int_t* ldz, fortran_int_t* isuppz, + void* work, const fortran_int_t* lwork, float* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZHEEVR( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, void* z, const fortran_int_t* ldz, fortran_int_t* isuppz, + void* work, const fortran_int_t* lwork, double* rwork, + const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of heevx +void LAPACK_CHEEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_ZHEEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, void* a, const fortran_int_t* lda, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, void* z, const fortran_int_t* ldz, void* work, + const fortran_int_t* lwork, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of hpev +void LAPACK_CHPEV( const char* jobz, const char* uplo, const fortran_int_t* n, + void* ap, float* w, void* z, const fortran_int_t* ldz, void* work, + float* rwork, fortran_int_t* info ); +void LAPACK_ZHPEV( const char* jobz, const char* uplo, const fortran_int_t* n, + void* ap, double* w, void* z, const fortran_int_t* ldz, void* work, + double* rwork, fortran_int_t* info ); + +// Value-type variants of hpevd +void LAPACK_CHPEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, void* ap, float* w, void* z, + const fortran_int_t* ldz, void* work, const fortran_int_t* lwork, + float* rwork, const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_ZHPEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, void* ap, double* w, void* z, + const fortran_int_t* ldz, void* work, const fortran_int_t* lwork, + double* rwork, const fortran_int_t* lrwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of hpevx +void LAPACK_CHPEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, void* ap, const float* vl, const float* vu, + const fortran_int_t* il, const fortran_int_t* iu, const float* abstol, + fortran_int_t* m, float* w, void* z, const fortran_int_t* ldz, + void* work, float* rwork, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_ZHPEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, void* ap, const double* vl, const double* vu, + const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, void* z, + const fortran_int_t* ldz, void* work, double* rwork, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of sbev +void LAPACK_SSBEV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, float* ab, const fortran_int_t* ldab, + float* w, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DSBEV( const char* jobz, const char* uplo, const fortran_int_t* n, + const fortran_int_t* kd, double* ab, const fortran_int_t* ldab, + double* w, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); + +// Value-type variants of sbevd +void LAPACK_SSBEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, float* ab, + const fortran_int_t* ldab, float* w, float* z, + const fortran_int_t* ldz, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_DSBEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, double* ab, + const fortran_int_t* ldab, double* w, double* z, + const fortran_int_t* ldz, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); + +// Value-type variants of sbevx +void LAPACK_SSBEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, float* ab, + const fortran_int_t* ldab, float* q, const fortran_int_t* ldq, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_DSBEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, const fortran_int_t* kd, double* ab, + const fortran_int_t* ldab, double* q, const fortran_int_t* ldq, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of spev +void LAPACK_SSPEV( const char* jobz, const char* uplo, const fortran_int_t* n, + float* ap, float* w, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DSPEV( const char* jobz, const char* uplo, const fortran_int_t* n, + double* ap, double* w, double* z, const fortran_int_t* ldz, + double* work, fortran_int_t* info ); + +// Value-type variants of spevd +void LAPACK_SSPEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, float* ap, float* w, float* z, + const fortran_int_t* ldz, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); +void LAPACK_DSPEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, double* ap, double* w, double* z, + const fortran_int_t* ldz, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); + +// Value-type variants of spevx +void LAPACK_SSPEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, float* ap, const float* vl, const float* vu, + const fortran_int_t* il, const fortran_int_t* iu, const float* abstol, + fortran_int_t* m, float* w, float* z, const fortran_int_t* ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail, + fortran_int_t* info ); +void LAPACK_DSPEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, double* ap, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, double* work, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of stev +void LAPACK_SSTEV( const char* jobz, const fortran_int_t* n, float* d, + float* e, float* z, const fortran_int_t* ldz, float* work, + fortran_int_t* info ); +void LAPACK_DSTEV( const char* jobz, const fortran_int_t* n, double* d, + double* e, double* z, const fortran_int_t* ldz, double* work, + fortran_int_t* info ); + +// Value-type variants of stevd +void LAPACK_SSTEVD( const char* jobz, const fortran_int_t* n, float* d, + float* e, float* z, const fortran_int_t* ldz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSTEVD( const char* jobz, const fortran_int_t* n, double* d, + double* e, double* z, const fortran_int_t* ldz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of stevr +void LAPACK_SSTEVR( const char* jobz, const char* range, + const fortran_int_t* n, float* d, float* e, const float* vl, + const float* vu, const fortran_int_t* il, const fortran_int_t* iu, + const float* abstol, fortran_int_t* m, float* w, float* z, + const fortran_int_t* ldz, fortran_int_t* isuppz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSTEVR( const char* jobz, const char* range, + const fortran_int_t* n, double* d, double* e, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, fortran_int_t* isuppz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of stevx +void LAPACK_SSTEVX( const char* jobz, const char* range, + const fortran_int_t* n, float* d, float* e, const float* vl, + const float* vu, const fortran_int_t* il, const fortran_int_t* iu, + const float* abstol, fortran_int_t* m, float* w, float* z, + const fortran_int_t* ldz, float* work, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_DSTEVX( const char* jobz, const char* range, + const fortran_int_t* n, double* d, double* e, const double* vl, + const double* vu, const fortran_int_t* il, const fortran_int_t* iu, + const double* abstol, fortran_int_t* m, double* w, double* z, + const fortran_int_t* ldz, double* work, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of syev +void LAPACK_SSYEV( const char* jobz, const char* uplo, const fortran_int_t* n, + float* a, const fortran_int_t* lda, float* w, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DSYEV( const char* jobz, const char* uplo, const fortran_int_t* n, + double* a, const fortran_int_t* lda, double* w, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of syevd +void LAPACK_SSYEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, float* a, const fortran_int_t* lda, float* w, + float* work, const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSYEVD( const char* jobz, const char* uplo, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + double* w, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, const fortran_int_t* liwork, + fortran_int_t* info ); + +// Value-type variants of syevr +void LAPACK_SSYEVR( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, float* a, const fortran_int_t* lda, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, float* z, const fortran_int_t* ldz, fortran_int_t* isuppz, + float* work, const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); +void LAPACK_DSYEVR( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, double* z, const fortran_int_t* ldz, fortran_int_t* isuppz, + double* work, const fortran_int_t* lwork, fortran_int_t* iwork, + const fortran_int_t* liwork, fortran_int_t* info ); + +// Value-type variants of syevx +void LAPACK_SSYEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, float* a, const fortran_int_t* lda, + const float* vl, const float* vu, const fortran_int_t* il, + const fortran_int_t* iu, const float* abstol, fortran_int_t* m, + float* w, float* z, const fortran_int_t* ldz, float* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); +void LAPACK_DSYEVX( const char* jobz, const char* range, const char* uplo, + const fortran_int_t* n, double* a, const fortran_int_t* lda, + const double* vl, const double* vu, const fortran_int_t* il, + const fortran_int_t* iu, const double* abstol, fortran_int_t* m, + double* w, double* z, const fortran_int_t* ldz, double* work, + const fortran_int_t* lwork, fortran_int_t* iwork, + fortran_int_t* ifail, fortran_int_t* info ); + +// Value-type variants of gels +void LAPACK_SGELS( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* nrhs, float* a, + const fortran_int_t* lda, float* b, const fortran_int_t* ldb, + float* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGELS( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* nrhs, double* a, + const fortran_int_t* lda, double* b, const fortran_int_t* ldb, + double* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGELS( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + void* work, const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_ZGELS( const char* trans, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* nrhs, void* a, + const fortran_int_t* lda, void* b, const fortran_int_t* ldb, + void* work, const fortran_int_t* lwork, fortran_int_t* info ); + +// Value-type variants of gelsd +void LAPACK_SGELSD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb, float* s, const float* rcond, + fortran_int_t* rank, float* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DGELSD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* s, const double* rcond, + fortran_int_t* rank, double* work, const fortran_int_t* lwork, + fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_CGELSD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, float* s, const float* rcond, + fortran_int_t* rank, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_ZGELSD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, const void* a, const fortran_int_t* lda, + void* b, const fortran_int_t* ldb, double* s, const double* rcond, + fortran_int_t* rank, void* work, const fortran_int_t* lwork, + double* rwork, fortran_int_t* iwork, fortran_int_t* info ); + +// Value-type variants of gelss +void LAPACK_SGELSS( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb, float* s, const float* rcond, + fortran_int_t* rank, float* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_DGELSS( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, double* s, const double* rcond, + fortran_int_t* rank, double* work, const fortran_int_t* lwork, + fortran_int_t* info ); +void LAPACK_CGELSS( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, float* s, const float* rcond, + fortran_int_t* rank, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* info ); +void LAPACK_ZGELSS( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, double* s, const double* rcond, + fortran_int_t* rank, void* work, const fortran_int_t* lwork, + double* rwork, fortran_int_t* info ); + +// Value-type variants of gelsy +void LAPACK_SGELSY( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, float* a, const fortran_int_t* lda, + float* b, const fortran_int_t* ldb, fortran_int_t* jpvt, + const float* rcond, fortran_int_t* rank, float* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_DGELSY( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, double* a, const fortran_int_t* lda, + double* b, const fortran_int_t* ldb, fortran_int_t* jpvt, + const double* rcond, fortran_int_t* rank, double* work, + const fortran_int_t* lwork, fortran_int_t* info ); +void LAPACK_CGELSY( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, fortran_int_t* jpvt, const float* rcond, + fortran_int_t* rank, void* work, const fortran_int_t* lwork, + float* rwork, fortran_int_t* info ); +void LAPACK_ZGELSY( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nrhs, void* a, const fortran_int_t* lda, void* b, + const fortran_int_t* ldb, fortran_int_t* jpvt, const double* rcond, + fortran_int_t* rank, void* work, const fortran_int_t* lwork, + double* rwork, fortran_int_t* info ); + +// +// LAPACK auxiliary routines +// + +// Value-type variants of larf +void LAPACK_SLARF( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const float* v, const fortran_int_t* incv, + const float* tau, float* c, const fortran_int_t* ldc, float* work ); +void LAPACK_DLARF( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const double* v, const fortran_int_t* incv, + const double* tau, double* c, const fortran_int_t* ldc, double* work ); +void LAPACK_CLARF( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const void* v, const fortran_int_t* incv, + const void* tau, void* c, const fortran_int_t* ldc, void* work ); +void LAPACK_ZLARF( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const void* v, const fortran_int_t* incv, + const void* tau, void* c, const fortran_int_t* ldc, void* work ); + +// Value-type variants of larfb +void LAPACK_SLARFB( const char* side, const char* trans, const char* direct, + const char* storev, const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const float* v, const fortran_int_t* ldv, + const float* t, const fortran_int_t* ldt, float* c, + const fortran_int_t* ldc, float* work, const fortran_int_t* ldwork ); +void LAPACK_DLARFB( const char* side, const char* trans, const char* direct, + const char* storev, const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const double* v, const fortran_int_t* ldv, + const double* t, const fortran_int_t* ldt, double* c, + const fortran_int_t* ldc, double* work, const fortran_int_t* ldwork ); +void LAPACK_CLARFB( const char* side, const char* trans, const char* direct, + const char* storev, const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* v, const fortran_int_t* ldv, + const void* t, const fortran_int_t* ldt, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* ldwork ); +void LAPACK_ZLARFB( const char* side, const char* trans, const char* direct, + const char* storev, const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* k, const void* v, const fortran_int_t* ldv, + const void* t, const fortran_int_t* ldt, void* c, + const fortran_int_t* ldc, void* work, const fortran_int_t* ldwork ); + +// Value-type variants of larfg +void LAPACK_SLARFG( const fortran_int_t* n, float* alpha, float* x, + const fortran_int_t* incx, float* tau ); +void LAPACK_DLARFG( const fortran_int_t* n, double* alpha, double* x, + const fortran_int_t* incx, double* tau ); +void LAPACK_CLARFG( const fortran_int_t* n, void* alpha, void* x, + const fortran_int_t* incx, void* tau ); +void LAPACK_ZLARFG( const fortran_int_t* n, void* alpha, void* x, + const fortran_int_t* incx, void* tau ); + +// Value-type variants of larft +void LAPACK_SLARFT( const char* direct, const char* storev, + const fortran_int_t* n, const fortran_int_t* k, float* v, + const fortran_int_t* ldv, const float* tau, float* t, + const fortran_int_t* ldt ); +void LAPACK_DLARFT( const char* direct, const char* storev, + const fortran_int_t* n, const fortran_int_t* k, double* v, + const fortran_int_t* ldv, const double* tau, double* t, + const fortran_int_t* ldt ); +void LAPACK_CLARFT( const char* direct, const char* storev, + const fortran_int_t* n, const fortran_int_t* k, void* v, + const fortran_int_t* ldv, const void* tau, void* t, + const fortran_int_t* ldt ); +void LAPACK_ZLARFT( const char* direct, const char* storev, + const fortran_int_t* n, const fortran_int_t* k, void* v, + const fortran_int_t* ldv, const void* tau, void* t, + const fortran_int_t* ldt ); + +// Value-type variants of larfx +void LAPACK_SLARFX( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const float* v, const float* tau, float* c, + const fortran_int_t* ldc, float* work ); +void LAPACK_DLARFX( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const double* v, const double* tau, double* c, + const fortran_int_t* ldc, double* work ); +void LAPACK_CLARFX( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const void* v, const void* tau, void* c, + const fortran_int_t* ldc, void* work ); +void LAPACK_ZLARFX( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const void* v, const void* tau, void* c, + const fortran_int_t* ldc, void* work ); + +// Value-type variants of largv +void LAPACK_SLARGV( const fortran_int_t* n, float* x, + const fortran_int_t* incx, float* y, const fortran_int_t* incy, + float* c, const fortran_int_t* incc ); +void LAPACK_DLARGV( const fortran_int_t* n, double* x, + const fortran_int_t* incx, double* y, const fortran_int_t* incy, + double* c, const fortran_int_t* incc ); +void LAPACK_CLARGV( const fortran_int_t* n, void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy, + float* c, const fortran_int_t* incc ); +void LAPACK_ZLARGV( const fortran_int_t* n, void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy, + double* c, const fortran_int_t* incc ); + +// Value-type variants of larnv +void LAPACK_SLARNV( const fortran_int_t* idist, fortran_int_t* iseed, + const fortran_int_t* n, float* x ); +void LAPACK_DLARNV( const fortran_int_t* idist, fortran_int_t* iseed, + const fortran_int_t* n, double* x ); +void LAPACK_CLARNV( const fortran_int_t* idist, fortran_int_t* iseed, + const fortran_int_t* n, void* x ); +void LAPACK_ZLARNV( const fortran_int_t* idist, fortran_int_t* iseed, + const fortran_int_t* n, void* x ); + +// Value-type variants of larrb +void LAPACK_SLARRB( const fortran_int_t* n, const float* d, const float* lld, + const fortran_int_t* ifirst, const fortran_int_t* ilast, + const float* rtol1, const float* rtol2, const fortran_int_t* offset, + float* w, float* wgap, float* werr, float* work, fortran_int_t* iwork, + const float* pivmin, const float* spdiam, const fortran_int_t* twist, + fortran_int_t* info ); +void LAPACK_DLARRB( const fortran_int_t* n, const double* d, + const double* lld, const fortran_int_t* ifirst, + const fortran_int_t* ilast, const double* rtol1, const double* rtol2, + const fortran_int_t* offset, double* w, double* wgap, double* werr, + double* work, fortran_int_t* iwork, const double* pivmin, + const double* spdiam, const fortran_int_t* twist, + fortran_int_t* info ); + +// Value-type variants of larre +void LAPACK_SLARRE( const char* range, const fortran_int_t* n, float* vl, + float* vu, const fortran_int_t* il, const fortran_int_t* iu, float* d, + float* e, float* e2, const float* rtol1, const float* rtol2, + const float* spltol, fortran_int_t* nsplit, fortran_int_t* isplit, + fortran_int_t* m, float* w, float* werr, float* wgap, + fortran_int_t* iblock, fortran_int_t* indexw, float* gers, + float* pivmin, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DLARRE( const char* range, const fortran_int_t* n, double* vl, + double* vu, const fortran_int_t* il, const fortran_int_t* iu, + double* d, double* e, double* e2, const double* rtol1, + const double* rtol2, const double* spltol, fortran_int_t* nsplit, + fortran_int_t* isplit, fortran_int_t* m, double* w, double* werr, + double* wgap, fortran_int_t* iblock, fortran_int_t* indexw, + double* gers, double* pivmin, double* work, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of langb +void LAPACK_SLANGB( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const float* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_DLANGB( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const double* ab, + const fortran_int_t* ldab, double* work ); +void LAPACK_CLANGB( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const void* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_ZLANGB( const char* norm, const fortran_int_t* n, + const fortran_int_t* kl, const fortran_int_t* ku, const void* ab, + const fortran_int_t* ldab, double* work ); + +// Value-type variants of lange +void LAPACK_SLANGE( const char* norm, const fortran_int_t* m, + const fortran_int_t* n, const float* a, const fortran_int_t* lda, + float* work ); +void LAPACK_DLANGE( const char* norm, const fortran_int_t* m, + const fortran_int_t* n, const double* a, const fortran_int_t* lda, + double* work ); +void LAPACK_CLANGE( const char* norm, const fortran_int_t* m, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + float* work ); +void LAPACK_ZLANGE( const char* norm, const fortran_int_t* m, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + double* work ); + +// Value-type variants of lanhb +void LAPACK_CLANHB( const char* norm, const char* uplo, + const fortran_int_t* n, const fortran_int_t* k, const void* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_ZLANHB( const char* norm, const char* uplo, + const fortran_int_t* n, const fortran_int_t* k, const void* ab, + const fortran_int_t* ldab, double* work ); + +// Value-type variants of lanhe +void LAPACK_CLANHE( const char* norm, const char* uplo, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + float* work ); +void LAPACK_ZLANHE( const char* norm, const char* uplo, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + double* work ); + +// Value-type variants of lanhp +void LAPACK_CLANHP( const char* norm, const char* uplo, + const fortran_int_t* n, const void* ap, float* work ); +void LAPACK_ZLANHP( const char* norm, const char* uplo, + const fortran_int_t* n, const void* ap, double* work ); + +// Value-type variants of lanhs +void LAPACK_SLANHS( const char* norm, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, float* work ); +void LAPACK_DLANHS( const char* norm, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, double* work ); +void LAPACK_CLANHS( const char* norm, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, float* work ); +void LAPACK_ZLANHS( const char* norm, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, double* work ); + +// Value-type variants of lansb +void LAPACK_SLANSB( const char* norm, const char* uplo, + const fortran_int_t* n, const fortran_int_t* k, const float* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_DLANSB( const char* norm, const char* uplo, + const fortran_int_t* n, const fortran_int_t* k, const double* ab, + const fortran_int_t* ldab, double* work ); +void LAPACK_CLANSB( const char* norm, const char* uplo, + const fortran_int_t* n, const fortran_int_t* k, const void* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_ZLANSB( const char* norm, const char* uplo, + const fortran_int_t* n, const fortran_int_t* k, const void* ab, + const fortran_int_t* ldab, double* work ); + +// Value-type variants of lansp +void LAPACK_SLANSP( const char* norm, const char* uplo, + const fortran_int_t* n, const float* ap, float* work ); +void LAPACK_DLANSP( const char* norm, const char* uplo, + const fortran_int_t* n, const double* ap, double* work ); +void LAPACK_CLANSP( const char* norm, const char* uplo, + const fortran_int_t* n, const void* ap, float* work ); +void LAPACK_ZLANSP( const char* norm, const char* uplo, + const fortran_int_t* n, const void* ap, double* work ); + +// Value-type variants of lansy +void LAPACK_SLANSY( const char* norm, const char* uplo, + const fortran_int_t* n, const float* a, const fortran_int_t* lda, + float* work ); +void LAPACK_DLANSY( const char* norm, const char* uplo, + const fortran_int_t* n, const double* a, const fortran_int_t* lda, + double* work ); +void LAPACK_CLANSY( const char* norm, const char* uplo, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + float* work ); +void LAPACK_ZLANSY( const char* norm, const char* uplo, + const fortran_int_t* n, const void* a, const fortran_int_t* lda, + double* work ); + +// Value-type variants of lantb +void LAPACK_SLANTB( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const float* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_DLANTB( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const double* ab, + const fortran_int_t* ldab, double* work ); +void LAPACK_CLANTB( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const void* ab, + const fortran_int_t* ldab, float* work ); +void LAPACK_ZLANTB( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const fortran_int_t* k, const void* ab, + const fortran_int_t* ldab, double* work ); + +// Value-type variants of lantp +void LAPACK_SLANTP( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const float* ap, float* work ); +void LAPACK_DLANTP( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const double* ap, double* work ); +void LAPACK_CLANTP( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const void* ap, float* work ); +void LAPACK_ZLANTP( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* n, const void* ap, double* work ); + +// Value-type variants of lantr +void LAPACK_SLANTR( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* m, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, float* work ); +void LAPACK_DLANTR( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* m, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, double* work ); +void LAPACK_CLANTR( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* m, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, float* work ); +void LAPACK_ZLANTR( const char* norm, const char* uplo, const char* diag, + const fortran_int_t* m, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, double* work ); + +// Value-type variants of labrd +void LAPACK_SLABRD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nb, float* a, const fortran_int_t* lda, float* d, + float* e, float* tauq, float* taup, float* x, + const fortran_int_t* ldx, float* y, const fortran_int_t* ldy ); +void LAPACK_DLABRD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nb, double* a, const fortran_int_t* lda, + double* d, double* e, double* tauq, double* taup, double* x, + const fortran_int_t* ldx, double* y, const fortran_int_t* ldy ); +void LAPACK_CLABRD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nb, void* a, const fortran_int_t* lda, float* d, + float* e, void* tauq, void* taup, void* x, const fortran_int_t* ldx, + void* y, const fortran_int_t* ldy ); +void LAPACK_ZLABRD( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* nb, void* a, const fortran_int_t* lda, double* d, + double* e, void* tauq, void* taup, void* x, const fortran_int_t* ldx, + void* y, const fortran_int_t* ldy ); + +// Value-type variants of lacgv +void LAPACK_CLACGV( const fortran_int_t* n, void* x, + const fortran_int_t* incx ); +void LAPACK_ZLACGV( const fortran_int_t* n, void* x, + const fortran_int_t* incx ); + +// Value-type variants of lacon +void LAPACK_SLACON( const fortran_int_t* n, float* v, float* x, + fortran_int_t* isgn, float* est, fortran_int_t* kase ); +void LAPACK_DLACON( const fortran_int_t* n, double* v, double* x, + fortran_int_t* isgn, double* est, fortran_int_t* kase ); +void LAPACK_CLACON( const fortran_int_t* n, void* v, void* x, float* est, + fortran_int_t* kase ); +void LAPACK_ZLACON( const fortran_int_t* n, void* v, void* x, double* est, + fortran_int_t* kase ); + +// Value-type variants of laebz +void LAPACK_SLAEBZ( const fortran_int_t* ijob, const fortran_int_t* nitmax, + const fortran_int_t* n, const fortran_int_t* mmax, + const fortran_int_t* minp, const fortran_int_t* nbmin, + const float* abstol, const float* reltol, const float* pivmin, + const float* d, const float* e, const float* e2, fortran_int_t* nval, + float* ab, float* c, fortran_int_t* mout, fortran_int_t* nab, + float* work, fortran_int_t* iwork, fortran_int_t* info ); +void LAPACK_DLAEBZ( const fortran_int_t* ijob, const fortran_int_t* nitmax, + const fortran_int_t* n, const fortran_int_t* mmax, + const fortran_int_t* minp, const fortran_int_t* nbmin, + const double* abstol, const double* reltol, const double* pivmin, + const double* d, const double* e, const double* e2, + fortran_int_t* nval, double* ab, double* c, fortran_int_t* mout, + fortran_int_t* nab, double* work, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of lalsd +void LAPACK_SLALSD( const char* uplo, const fortran_int_t* smlsiz, + const fortran_int_t* n, const fortran_int_t* nrhs, float* d, float* e, + float* b, const fortran_int_t* ldb, const float* rcond, + fortran_int_t* rank, float* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_DLALSD( const char* uplo, const fortran_int_t* smlsiz, + const fortran_int_t* n, const fortran_int_t* nrhs, double* d, + double* e, double* b, const fortran_int_t* ldb, const double* rcond, + fortran_int_t* rank, double* work, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_CLALSD( const char* uplo, const fortran_int_t* smlsiz, + const fortran_int_t* n, const fortran_int_t* nrhs, float* d, float* e, + void* b, const fortran_int_t* ldb, const float* rcond, + fortran_int_t* rank, void* work, float* rwork, fortran_int_t* iwork, + fortran_int_t* info ); +void LAPACK_ZLALSD( const char* uplo, const fortran_int_t* smlsiz, + const fortran_int_t* n, const fortran_int_t* nrhs, double* d, + double* e, void* b, const fortran_int_t* ldb, const double* rcond, + fortran_int_t* rank, void* work, double* rwork, fortran_int_t* iwork, + fortran_int_t* info ); + +// Value-type variants of largv +void LAPACK_SLARGV( const fortran_int_t* n, float* x, + const fortran_int_t* incx, float* y, const fortran_int_t* incy, + float* c, const fortran_int_t* incc ); +void LAPACK_DLARGV( const fortran_int_t* n, double* x, + const fortran_int_t* incx, double* y, const fortran_int_t* incy, + double* c, const fortran_int_t* incc ); +void LAPACK_CLARGV( const fortran_int_t* n, void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy, + float* c, const fortran_int_t* incc ); +void LAPACK_ZLARGV( const fortran_int_t* n, void* x, + const fortran_int_t* incx, void* y, const fortran_int_t* incy, + double* c, const fortran_int_t* incc ); + +// Value-type variants of larz +void LAPACK_SLARZ( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* l, const float* v, + const fortran_int_t* incv, const float* tau, float* c, + const fortran_int_t* ldc, float* work ); +void LAPACK_DLARZ( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* l, const double* v, + const fortran_int_t* incv, const double* tau, double* c, + const fortran_int_t* ldc, double* work ); +void LAPACK_CLARZ( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* l, const void* v, + const fortran_int_t* incv, const void* tau, void* c, + const fortran_int_t* ldc, void* work ); +void LAPACK_ZLARZ( const char* side, const fortran_int_t* m, + const fortran_int_t* n, const fortran_int_t* l, const void* v, + const fortran_int_t* incv, const void* tau, void* c, + const fortran_int_t* ldc, void* work ); + +// Value-type variants of latrd +void LAPACK_SLATRD( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nb, float* a, const fortran_int_t* lda, float* e, + float* tau, float* w, const fortran_int_t* ldw ); +void LAPACK_DLATRD( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nb, double* a, const fortran_int_t* lda, + double* e, double* tau, double* w, const fortran_int_t* ldw ); +void LAPACK_CLATRD( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nb, void* a, const fortran_int_t* lda, float* e, + void* tau, void* w, const fortran_int_t* ldw ); +void LAPACK_ZLATRD( const char* uplo, const fortran_int_t* n, + const fortran_int_t* nb, void* a, const fortran_int_t* lda, double* e, + void* tau, void* w, const fortran_int_t* ldw ); + +// Value-type variants of latrs +void LAPACK_SLATRS( const char* uplo, const char* trans, const char* diag, + const char* normin, const fortran_int_t* n, const float* a, + const fortran_int_t* lda, float* x, float* scale, float* cnorm, + fortran_int_t* info ); +void LAPACK_DLATRS( const char* uplo, const char* trans, const char* diag, + const char* normin, const fortran_int_t* n, const double* a, + const fortran_int_t* lda, double* x, double* scale, double* cnorm, + fortran_int_t* info ); +void LAPACK_CLATRS( const char* uplo, const char* trans, const char* diag, + const char* normin, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, void* x, float* scale, float* cnorm, + fortran_int_t* info ); +void LAPACK_ZLATRS( const char* uplo, const char* trans, const char* diag, + const char* normin, const fortran_int_t* n, const void* a, + const fortran_int_t* lda, void* x, double* scale, double* cnorm, + fortran_int_t* info ); + +// Value-type variants of latrz +void LAPACK_SLATRZ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* l, float* a, const fortran_int_t* lda, + float* tau, float* work ); +void LAPACK_DLATRZ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* l, double* a, const fortran_int_t* lda, + double* tau, double* work ); +void LAPACK_CLATRZ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* l, void* a, const fortran_int_t* lda, void* tau, + void* work ); +void LAPACK_ZLATRZ( const fortran_int_t* m, const fortran_int_t* n, + const fortran_int_t* l, void* a, const fortran_int_t* lda, void* tau, + void* work ); + +// +// LAPACK auxiliary routines +// + +fortran_int_t LAPACK_ILAENV(const fortran_int_t* ispec, const char* name, + const char* opt, const fortran_int_t* n1, const fortran_int_t* n2, + const fortran_int_t* n3, const fortran_int_t* n4, fortran_int_t, + fortran_int_t); + +} + +#endif + diff --git a/sdk/boost/numeric/bindings/lapack/detail/lapack_names.h b/sdk/boost/numeric/bindings/lapack/detail/lapack_names.h new file mode 100644 index 0000000..c87712f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/detail/lapack_names.h @@ -0,0 +1,1442 @@ +// +// Copyright (c) 2003--2009 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_LAPACK_NAMES_H +#define BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_LAPACK_NAMES_H + +#include + +// +// LAPACK computational routines +// + +// Value-type variants of hbgst +#define LAPACK_CHBGST FORTRAN_ID2( chbgst, CHBGST ) +#define LAPACK_ZHBGST FORTRAN_ID2( zhbgst, ZHBGST ) + +// Value-type variants of hegst +#define LAPACK_CHEGST FORTRAN_ID2( chegst, CHEGST ) +#define LAPACK_ZHEGST FORTRAN_ID2( zhegst, ZHEGST ) + +// Value-type variants of pbstf +#define LAPACK_SPBSTF FORTRAN_ID2( spbstf, SPBSTF ) +#define LAPACK_DPBSTF FORTRAN_ID2( dpbstf, DPBSTF ) +#define LAPACK_CPBSTF FORTRAN_ID2( cpbstf, CPBSTF ) +#define LAPACK_ZPBSTF FORTRAN_ID2( zpbstf, ZPBSTF ) + +// Value-type variants of sbgst +#define LAPACK_SSBGST FORTRAN_ID2( ssbgst, SSBGST ) +#define LAPACK_DSBGST FORTRAN_ID2( dsbgst, DSBGST ) + +// Value-type variants of sygst +#define LAPACK_SSYGST FORTRAN_ID2( ssygst, SSYGST ) +#define LAPACK_DSYGST FORTRAN_ID2( dsygst, DSYGST ) + +// Value-type variants of ggqrf +#define LAPACK_SGGQRF FORTRAN_ID2( sggqrf, SGGQRF ) +#define LAPACK_DGGQRF FORTRAN_ID2( dggqrf, DGGQRF ) +#define LAPACK_CGGQRF FORTRAN_ID2( cggqrf, CGGQRF ) +#define LAPACK_ZGGQRF FORTRAN_ID2( zggqrf, ZGGQRF ) + +// Value-type variants of ggrqf +#define LAPACK_SGGRQF FORTRAN_ID2( sggrqf, SGGRQF ) +#define LAPACK_DGGRQF FORTRAN_ID2( dggrqf, DGGRQF ) +#define LAPACK_CGGRQF FORTRAN_ID2( cggrqf, CGGRQF ) +#define LAPACK_ZGGRQF FORTRAN_ID2( zggrqf, ZGGRQF ) + +// Value-type variants of gelqf +#define LAPACK_SGELQF FORTRAN_ID2( sgelqf, SGELQF ) +#define LAPACK_DGELQF FORTRAN_ID2( dgelqf, DGELQF ) +#define LAPACK_CGELQF FORTRAN_ID2( cgelqf, CGELQF ) +#define LAPACK_ZGELQF FORTRAN_ID2( zgelqf, ZGELQF ) + +// Value-type variants of geqlf +#define LAPACK_SGEQLF FORTRAN_ID2( sgeqlf, SGEQLF ) +#define LAPACK_DGEQLF FORTRAN_ID2( dgeqlf, DGEQLF ) +#define LAPACK_CGEQLF FORTRAN_ID2( cgeqlf, CGEQLF ) +#define LAPACK_ZGEQLF FORTRAN_ID2( zgeqlf, ZGEQLF ) + +// Value-type variants of geqp3 +#define LAPACK_SGEQP3 FORTRAN_ID2( sgeqp3, SGEQP3 ) +#define LAPACK_DGEQP3 FORTRAN_ID2( dgeqp3, DGEQP3 ) +#define LAPACK_CGEQP3 FORTRAN_ID2( cgeqp3, CGEQP3 ) +#define LAPACK_ZGEQP3 FORTRAN_ID2( zgeqp3, ZGEQP3 ) + +// Value-type variants of geqrf +#define LAPACK_SGEQRF FORTRAN_ID2( sgeqrf, SGEQRF ) +#define LAPACK_DGEQRF FORTRAN_ID2( dgeqrf, DGEQRF ) +#define LAPACK_CGEQRF FORTRAN_ID2( cgeqrf, CGEQRF ) +#define LAPACK_ZGEQRF FORTRAN_ID2( zgeqrf, ZGEQRF ) + +// Value-type variants of gerqf +#define LAPACK_SGERQF FORTRAN_ID2( sgerqf, SGERQF ) +#define LAPACK_DGERQF FORTRAN_ID2( dgerqf, DGERQF ) +#define LAPACK_CGERQF FORTRAN_ID2( cgerqf, CGERQF ) +#define LAPACK_ZGERQF FORTRAN_ID2( zgerqf, ZGERQF ) + +// Value-type variants of orglq +#define LAPACK_SORGLQ FORTRAN_ID2( sorglq, SORGLQ ) +#define LAPACK_DORGLQ FORTRAN_ID2( dorglq, DORGLQ ) + +// Value-type variants of orgql +#define LAPACK_SORGQL FORTRAN_ID2( sorgql, SORGQL ) +#define LAPACK_DORGQL FORTRAN_ID2( dorgql, DORGQL ) + +// Value-type variants of orgqr +#define LAPACK_SORGQR FORTRAN_ID2( sorgqr, SORGQR ) +#define LAPACK_DORGQR FORTRAN_ID2( dorgqr, DORGQR ) + +// Value-type variants of orgrq +#define LAPACK_SORGRQ FORTRAN_ID2( sorgrq, SORGRQ ) +#define LAPACK_DORGRQ FORTRAN_ID2( dorgrq, DORGRQ ) + +// Value-type variants of ormlq +#define LAPACK_SORMLQ FORTRAN_ID2( sormlq, SORMLQ ) +#define LAPACK_DORMLQ FORTRAN_ID2( dormlq, DORMLQ ) + +// Value-type variants of ormql +#define LAPACK_SORMQL FORTRAN_ID2( sormql, SORMQL ) +#define LAPACK_DORMQL FORTRAN_ID2( dormql, DORMQL ) + +// Value-type variants of ormqr +#define LAPACK_SORMQR FORTRAN_ID2( sormqr, SORMQR ) +#define LAPACK_DORMQR FORTRAN_ID2( dormqr, DORMQR ) + +// Value-type variants of ormrq +#define LAPACK_SORMRQ FORTRAN_ID2( sormrq, SORMRQ ) +#define LAPACK_DORMRQ FORTRAN_ID2( dormrq, DORMRQ ) + +// Value-type variants of ormrz +#define LAPACK_SORMRZ FORTRAN_ID2( sormrz, SORMRZ ) +#define LAPACK_DORMRZ FORTRAN_ID2( dormrz, DORMRZ ) + +// Value-type variants of tzrzf +#define LAPACK_STZRZF FORTRAN_ID2( stzrzf, STZRZF ) +#define LAPACK_DTZRZF FORTRAN_ID2( dtzrzf, DTZRZF ) +#define LAPACK_CTZRZF FORTRAN_ID2( ctzrzf, CTZRZF ) +#define LAPACK_ZTZRZF FORTRAN_ID2( ztzrzf, ZTZRZF ) + +// Value-type variants of unglq +#define LAPACK_CUNGLQ FORTRAN_ID2( cunglq, CUNGLQ ) +#define LAPACK_ZUNGLQ FORTRAN_ID2( zunglq, ZUNGLQ ) + +// Value-type variants of ungql +#define LAPACK_CUNGQL FORTRAN_ID2( cungql, CUNGQL ) +#define LAPACK_ZUNGQL FORTRAN_ID2( zungql, ZUNGQL ) + +// Value-type variants of ungqr +#define LAPACK_CUNGQR FORTRAN_ID2( cungqr, CUNGQR ) +#define LAPACK_ZUNGQR FORTRAN_ID2( zungqr, ZUNGQR ) + +// Value-type variants of ungrq +#define LAPACK_CUNGRQ FORTRAN_ID2( cungrq, CUNGRQ ) +#define LAPACK_ZUNGRQ FORTRAN_ID2( zungrq, ZUNGRQ ) + +// Value-type variants of unmlq +#define LAPACK_CUNMLQ FORTRAN_ID2( cunmlq, CUNMLQ ) +#define LAPACK_ZUNMLQ FORTRAN_ID2( zunmlq, ZUNMLQ ) + +// Value-type variants of unmql +#define LAPACK_CUNMQL FORTRAN_ID2( cunmql, CUNMQL ) +#define LAPACK_ZUNMQL FORTRAN_ID2( zunmql, ZUNMQL ) + +// Value-type variants of unmqr +#define LAPACK_CUNMQR FORTRAN_ID2( cunmqr, CUNMQR ) +#define LAPACK_ZUNMQR FORTRAN_ID2( zunmqr, ZUNMQR ) + +// Value-type variants of unmrq +#define LAPACK_CUNMRQ FORTRAN_ID2( cunmrq, CUNMRQ ) +#define LAPACK_ZUNMRQ FORTRAN_ID2( zunmrq, ZUNMRQ ) + +// Value-type variants of unmrz +#define LAPACK_CUNMRZ FORTRAN_ID2( cunmrz, CUNMRZ ) +#define LAPACK_ZUNMRZ FORTRAN_ID2( zunmrz, ZUNMRZ ) + +// Value-type variants of bdsdc +#define LAPACK_SBDSDC FORTRAN_ID2( sbdsdc, SBDSDC ) +#define LAPACK_DBDSDC FORTRAN_ID2( dbdsdc, DBDSDC ) + +// Value-type variants of bdsqr +#define LAPACK_SBDSQR FORTRAN_ID2( sbdsqr, SBDSQR ) +#define LAPACK_DBDSQR FORTRAN_ID2( dbdsqr, DBDSQR ) +#define LAPACK_CBDSQR FORTRAN_ID2( cbdsqr, CBDSQR ) +#define LAPACK_ZBDSQR FORTRAN_ID2( zbdsqr, ZBDSQR ) + +// Value-type variants of gbbrd +#define LAPACK_SGBBRD FORTRAN_ID2( sgbbrd, SGBBRD ) +#define LAPACK_DGBBRD FORTRAN_ID2( dgbbrd, DGBBRD ) +#define LAPACK_CGBBRD FORTRAN_ID2( cgbbrd, CGBBRD ) +#define LAPACK_ZGBBRD FORTRAN_ID2( zgbbrd, ZGBBRD ) + +// Value-type variants of gebrd +#define LAPACK_SGEBRD FORTRAN_ID2( sgebrd, SGEBRD ) +#define LAPACK_DGEBRD FORTRAN_ID2( dgebrd, DGEBRD ) +#define LAPACK_CGEBRD FORTRAN_ID2( cgebrd, CGEBRD ) +#define LAPACK_ZGEBRD FORTRAN_ID2( zgebrd, ZGEBRD ) + +// Value-type variants of orgbr +#define LAPACK_SORGBR FORTRAN_ID2( sorgbr, SORGBR ) +#define LAPACK_DORGBR FORTRAN_ID2( dorgbr, DORGBR ) + +// Value-type variants of ormbr +#define LAPACK_SORMBR FORTRAN_ID2( sormbr, SORMBR ) +#define LAPACK_DORMBR FORTRAN_ID2( dormbr, DORMBR ) + +// Value-type variants of ungbr +#define LAPACK_CUNGBR FORTRAN_ID2( cungbr, CUNGBR ) +#define LAPACK_ZUNGBR FORTRAN_ID2( zungbr, ZUNGBR ) + +// Value-type variants of unmbr +#define LAPACK_CUNMBR FORTRAN_ID2( cunmbr, CUNMBR ) +#define LAPACK_ZUNMBR FORTRAN_ID2( zunmbr, ZUNMBR ) + +// Value-type variants of gebak +#define LAPACK_SGEBAK FORTRAN_ID2( sgebak, SGEBAK ) +#define LAPACK_DGEBAK FORTRAN_ID2( dgebak, DGEBAK ) +#define LAPACK_CGEBAK FORTRAN_ID2( cgebak, CGEBAK ) +#define LAPACK_ZGEBAK FORTRAN_ID2( zgebak, ZGEBAK ) + +// Value-type variants of gebal +#define LAPACK_SGEBAL FORTRAN_ID2( sgebal, SGEBAL ) +#define LAPACK_DGEBAL FORTRAN_ID2( dgebal, DGEBAL ) +#define LAPACK_CGEBAL FORTRAN_ID2( cgebal, CGEBAL ) +#define LAPACK_ZGEBAL FORTRAN_ID2( zgebal, ZGEBAL ) + +// Value-type variants of gehrd +#define LAPACK_SGEHRD FORTRAN_ID2( sgehrd, SGEHRD ) +#define LAPACK_DGEHRD FORTRAN_ID2( dgehrd, DGEHRD ) +#define LAPACK_CGEHRD FORTRAN_ID2( cgehrd, CGEHRD ) +#define LAPACK_ZGEHRD FORTRAN_ID2( zgehrd, ZGEHRD ) + +// Value-type variants of hsein +#define LAPACK_SHSEIN FORTRAN_ID2( shsein, SHSEIN ) +#define LAPACK_DHSEIN FORTRAN_ID2( dhsein, DHSEIN ) +#define LAPACK_CHSEIN FORTRAN_ID2( chsein, CHSEIN ) +#define LAPACK_ZHSEIN FORTRAN_ID2( zhsein, ZHSEIN ) + +// Value-type variants of hseqr +#define LAPACK_SHSEQR FORTRAN_ID2( shseqr, SHSEQR ) +#define LAPACK_DHSEQR FORTRAN_ID2( dhseqr, DHSEQR ) +#define LAPACK_CHSEQR FORTRAN_ID2( chseqr, CHSEQR ) +#define LAPACK_ZHSEQR FORTRAN_ID2( zhseqr, ZHSEQR ) + +// Value-type variants of orghr +#define LAPACK_SORGHR FORTRAN_ID2( sorghr, SORGHR ) +#define LAPACK_DORGHR FORTRAN_ID2( dorghr, DORGHR ) + +// Value-type variants of ormhr +#define LAPACK_SORMHR FORTRAN_ID2( sormhr, SORMHR ) +#define LAPACK_DORMHR FORTRAN_ID2( dormhr, DORMHR ) + +// Value-type variants of trevc +#define LAPACK_STREVC FORTRAN_ID2( strevc, STREVC ) +#define LAPACK_DTREVC FORTRAN_ID2( dtrevc, DTREVC ) +#define LAPACK_CTREVC FORTRAN_ID2( ctrevc, CTREVC ) +#define LAPACK_ZTREVC FORTRAN_ID2( ztrevc, ZTREVC ) + +// Value-type variants of trexc +#define LAPACK_STREXC FORTRAN_ID2( strexc, STREXC ) +#define LAPACK_DTREXC FORTRAN_ID2( dtrexc, DTREXC ) +#define LAPACK_CTREXC FORTRAN_ID2( ctrexc, CTREXC ) +#define LAPACK_ZTREXC FORTRAN_ID2( ztrexc, ZTREXC ) + +// Value-type variants of trsen +#define LAPACK_CTRSEN FORTRAN_ID2( ctrsen, CTRSEN ) +#define LAPACK_ZTRSEN FORTRAN_ID2( ztrsen, ZTRSEN ) + +// Value-type variants of trsna +#define LAPACK_STRSNA FORTRAN_ID2( strsna, STRSNA ) +#define LAPACK_DTRSNA FORTRAN_ID2( dtrsna, DTRSNA ) +#define LAPACK_CTRSNA FORTRAN_ID2( ctrsna, CTRSNA ) +#define LAPACK_ZTRSNA FORTRAN_ID2( ztrsna, ZTRSNA ) + +// Value-type variants of trsyl +#define LAPACK_STRSYL FORTRAN_ID2( strsyl, STRSYL ) +#define LAPACK_DTRSYL FORTRAN_ID2( dtrsyl, DTRSYL ) +#define LAPACK_CTRSYL FORTRAN_ID2( ctrsyl, CTRSYL ) +#define LAPACK_ZTRSYL FORTRAN_ID2( ztrsyl, ZTRSYL ) + +// Value-type variants of unghr +#define LAPACK_CUNGHR FORTRAN_ID2( cunghr, CUNGHR ) +#define LAPACK_ZUNGHR FORTRAN_ID2( zunghr, ZUNGHR ) + +// Value-type variants of unmhr +#define LAPACK_CUNMHR FORTRAN_ID2( cunmhr, CUNMHR ) +#define LAPACK_ZUNMHR FORTRAN_ID2( zunmhr, ZUNMHR ) + +// Value-type variants of gbcon +#define LAPACK_SGBCON FORTRAN_ID2( sgbcon, SGBCON ) +#define LAPACK_DGBCON FORTRAN_ID2( dgbcon, DGBCON ) +#define LAPACK_CGBCON FORTRAN_ID2( cgbcon, CGBCON ) +#define LAPACK_ZGBCON FORTRAN_ID2( zgbcon, ZGBCON ) + +// Value-type variants of gbequ +#define LAPACK_SGBEQU FORTRAN_ID2( sgbequ, SGBEQU ) +#define LAPACK_DGBEQU FORTRAN_ID2( dgbequ, DGBEQU ) +#define LAPACK_CGBEQU FORTRAN_ID2( cgbequ, CGBEQU ) +#define LAPACK_ZGBEQU FORTRAN_ID2( zgbequ, ZGBEQU ) + +// Value-type variants of gbrfs +#define LAPACK_SGBRFS FORTRAN_ID2( sgbrfs, SGBRFS ) +#define LAPACK_DGBRFS FORTRAN_ID2( dgbrfs, DGBRFS ) +#define LAPACK_CGBRFS FORTRAN_ID2( cgbrfs, CGBRFS ) +#define LAPACK_ZGBRFS FORTRAN_ID2( zgbrfs, ZGBRFS ) + +// Value-type variants of gbtrf +#define LAPACK_SGBTRF FORTRAN_ID2( sgbtrf, SGBTRF ) +#define LAPACK_DGBTRF FORTRAN_ID2( dgbtrf, DGBTRF ) +#define LAPACK_CGBTRF FORTRAN_ID2( cgbtrf, CGBTRF ) +#define LAPACK_ZGBTRF FORTRAN_ID2( zgbtrf, ZGBTRF ) + +// Value-type variants of gbtrs +#define LAPACK_SGBTRS FORTRAN_ID2( sgbtrs, SGBTRS ) +#define LAPACK_DGBTRS FORTRAN_ID2( dgbtrs, DGBTRS ) +#define LAPACK_CGBTRS FORTRAN_ID2( cgbtrs, CGBTRS ) +#define LAPACK_ZGBTRS FORTRAN_ID2( zgbtrs, ZGBTRS ) + +// Value-type variants of gecon +#define LAPACK_SGECON FORTRAN_ID2( sgecon, SGECON ) +#define LAPACK_DGECON FORTRAN_ID2( dgecon, DGECON ) +#define LAPACK_CGECON FORTRAN_ID2( cgecon, CGECON ) +#define LAPACK_ZGECON FORTRAN_ID2( zgecon, ZGECON ) + +// Value-type variants of geequ +#define LAPACK_SGEEQU FORTRAN_ID2( sgeequ, SGEEQU ) +#define LAPACK_DGEEQU FORTRAN_ID2( dgeequ, DGEEQU ) +#define LAPACK_CGEEQU FORTRAN_ID2( cgeequ, CGEEQU ) +#define LAPACK_ZGEEQU FORTRAN_ID2( zgeequ, ZGEEQU ) + +// Value-type variants of gerfs +#define LAPACK_SGERFS FORTRAN_ID2( sgerfs, SGERFS ) +#define LAPACK_DGERFS FORTRAN_ID2( dgerfs, DGERFS ) +#define LAPACK_CGERFS FORTRAN_ID2( cgerfs, CGERFS ) +#define LAPACK_ZGERFS FORTRAN_ID2( zgerfs, ZGERFS ) + +// Value-type variants of getrf +#define LAPACK_SGETRF FORTRAN_ID2( sgetrf, SGETRF ) +#define LAPACK_DGETRF FORTRAN_ID2( dgetrf, DGETRF ) +#define LAPACK_CGETRF FORTRAN_ID2( cgetrf, CGETRF ) +#define LAPACK_ZGETRF FORTRAN_ID2( zgetrf, ZGETRF ) + +// Value-type variants of getri +#define LAPACK_SGETRI FORTRAN_ID2( sgetri, SGETRI ) +#define LAPACK_DGETRI FORTRAN_ID2( dgetri, DGETRI ) +#define LAPACK_CGETRI FORTRAN_ID2( cgetri, CGETRI ) +#define LAPACK_ZGETRI FORTRAN_ID2( zgetri, ZGETRI ) + +// Value-type variants of getrs +#define LAPACK_SGETRS FORTRAN_ID2( sgetrs, SGETRS ) +#define LAPACK_DGETRS FORTRAN_ID2( dgetrs, DGETRS ) +#define LAPACK_CGETRS FORTRAN_ID2( cgetrs, CGETRS ) +#define LAPACK_ZGETRS FORTRAN_ID2( zgetrs, ZGETRS ) + +// Value-type variants of gtrfs +#define LAPACK_SGTRFS FORTRAN_ID2( sgtrfs, SGTRFS ) +#define LAPACK_DGTRFS FORTRAN_ID2( dgtrfs, DGTRFS ) +#define LAPACK_CGTRFS FORTRAN_ID2( cgtrfs, CGTRFS ) +#define LAPACK_ZGTRFS FORTRAN_ID2( zgtrfs, ZGTRFS ) + +// Value-type variants of gttrs +#define LAPACK_SGTTRS FORTRAN_ID2( sgttrs, SGTTRS ) +#define LAPACK_DGTTRS FORTRAN_ID2( dgttrs, DGTTRS ) +#define LAPACK_CGTTRS FORTRAN_ID2( cgttrs, CGTTRS ) +#define LAPACK_ZGTTRS FORTRAN_ID2( zgttrs, ZGTTRS ) + +// Value-type variants of hecon +#define LAPACK_CHECON FORTRAN_ID2( checon, CHECON ) +#define LAPACK_ZHECON FORTRAN_ID2( zhecon, ZHECON ) + +// Value-type variants of herfs +#define LAPACK_CHERFS FORTRAN_ID2( cherfs, CHERFS ) +#define LAPACK_ZHERFS FORTRAN_ID2( zherfs, ZHERFS ) + +// Value-type variants of hetrf +#define LAPACK_CHETRF FORTRAN_ID2( chetrf, CHETRF ) +#define LAPACK_ZHETRF FORTRAN_ID2( zhetrf, ZHETRF ) + +// Value-type variants of hetri +#define LAPACK_CHETRI FORTRAN_ID2( chetri, CHETRI ) +#define LAPACK_ZHETRI FORTRAN_ID2( zhetri, ZHETRI ) + +// Value-type variants of hetrs +#define LAPACK_CHETRS FORTRAN_ID2( chetrs, CHETRS ) +#define LAPACK_ZHETRS FORTRAN_ID2( zhetrs, ZHETRS ) + +// Value-type variants of hpcon +#define LAPACK_CHPCON FORTRAN_ID2( chpcon, CHPCON ) +#define LAPACK_ZHPCON FORTRAN_ID2( zhpcon, ZHPCON ) + +// Value-type variants of hprfs +#define LAPACK_CHPRFS FORTRAN_ID2( chprfs, CHPRFS ) +#define LAPACK_ZHPRFS FORTRAN_ID2( zhprfs, ZHPRFS ) + +// Value-type variants of hptrf +#define LAPACK_CHPTRF FORTRAN_ID2( chptrf, CHPTRF ) +#define LAPACK_ZHPTRF FORTRAN_ID2( zhptrf, ZHPTRF ) + +// Value-type variants of hptri +#define LAPACK_CHPTRI FORTRAN_ID2( chptri, CHPTRI ) +#define LAPACK_ZHPTRI FORTRAN_ID2( zhptri, ZHPTRI ) + +// Value-type variants of hptrs +#define LAPACK_CHPTRS FORTRAN_ID2( chptrs, CHPTRS ) +#define LAPACK_ZHPTRS FORTRAN_ID2( zhptrs, ZHPTRS ) + +// Value-type variants of pbcon +#define LAPACK_SPBCON FORTRAN_ID2( spbcon, SPBCON ) +#define LAPACK_DPBCON FORTRAN_ID2( dpbcon, DPBCON ) +#define LAPACK_CPBCON FORTRAN_ID2( cpbcon, CPBCON ) +#define LAPACK_ZPBCON FORTRAN_ID2( zpbcon, ZPBCON ) + +// Value-type variants of pbequ +#define LAPACK_SPBEQU FORTRAN_ID2( spbequ, SPBEQU ) +#define LAPACK_DPBEQU FORTRAN_ID2( dpbequ, DPBEQU ) +#define LAPACK_CPBEQU FORTRAN_ID2( cpbequ, CPBEQU ) +#define LAPACK_ZPBEQU FORTRAN_ID2( zpbequ, ZPBEQU ) + +// Value-type variants of pbrfs +#define LAPACK_SPBRFS FORTRAN_ID2( spbrfs, SPBRFS ) +#define LAPACK_DPBRFS FORTRAN_ID2( dpbrfs, DPBRFS ) +#define LAPACK_CPBRFS FORTRAN_ID2( cpbrfs, CPBRFS ) +#define LAPACK_ZPBRFS FORTRAN_ID2( zpbrfs, ZPBRFS ) + +// Value-type variants of pbtrf +#define LAPACK_SPBTRF FORTRAN_ID2( spbtrf, SPBTRF ) +#define LAPACK_DPBTRF FORTRAN_ID2( dpbtrf, DPBTRF ) +#define LAPACK_CPBTRF FORTRAN_ID2( cpbtrf, CPBTRF ) +#define LAPACK_ZPBTRF FORTRAN_ID2( zpbtrf, ZPBTRF ) + +// Value-type variants of pbtrs +#define LAPACK_SPBTRS FORTRAN_ID2( spbtrs, SPBTRS ) +#define LAPACK_DPBTRS FORTRAN_ID2( dpbtrs, DPBTRS ) +#define LAPACK_CPBTRS FORTRAN_ID2( cpbtrs, CPBTRS ) +#define LAPACK_ZPBTRS FORTRAN_ID2( zpbtrs, ZPBTRS ) + +// Value-type variants of pftrf +#define LAPACK_SPFTRF FORTRAN_ID2( spftrf, SPFTRF ) +#define LAPACK_DPFTRF FORTRAN_ID2( dpftrf, DPFTRF ) +#define LAPACK_CPFTRF FORTRAN_ID2( cpftrf, CPFTRF ) +#define LAPACK_ZPFTRF FORTRAN_ID2( zpftrf, ZPFTRF ) + +// Value-type variants of pftri +#define LAPACK_SPFTRI FORTRAN_ID2( spftri, SPFTRI ) +#define LAPACK_DPFTRI FORTRAN_ID2( dpftri, DPFTRI ) +#define LAPACK_CPFTRI FORTRAN_ID2( cpftri, CPFTRI ) +#define LAPACK_ZPFTRI FORTRAN_ID2( zpftri, ZPFTRI ) + +// Value-type variants of pftrs +#define LAPACK_SPFTRS FORTRAN_ID2( spftrs, SPFTRS ) +#define LAPACK_DPFTRS FORTRAN_ID2( dpftrs, DPFTRS ) +#define LAPACK_CPFTRS FORTRAN_ID2( cpftrs, CPFTRS ) +#define LAPACK_ZPFTRS FORTRAN_ID2( zpftrs, ZPFTRS ) + +// Value-type variants of pocon +#define LAPACK_SPOCON FORTRAN_ID2( spocon, SPOCON ) +#define LAPACK_DPOCON FORTRAN_ID2( dpocon, DPOCON ) +#define LAPACK_CPOCON FORTRAN_ID2( cpocon, CPOCON ) +#define LAPACK_ZPOCON FORTRAN_ID2( zpocon, ZPOCON ) + +// Value-type variants of poequ +#define LAPACK_SPOEQU FORTRAN_ID2( spoequ, SPOEQU ) +#define LAPACK_DPOEQU FORTRAN_ID2( dpoequ, DPOEQU ) +#define LAPACK_CPOEQU FORTRAN_ID2( cpoequ, CPOEQU ) +#define LAPACK_ZPOEQU FORTRAN_ID2( zpoequ, ZPOEQU ) + +// Value-type variants of porfs +#define LAPACK_SPORFS FORTRAN_ID2( sporfs, SPORFS ) +#define LAPACK_DPORFS FORTRAN_ID2( dporfs, DPORFS ) +#define LAPACK_CPORFS FORTRAN_ID2( cporfs, CPORFS ) +#define LAPACK_ZPORFS FORTRAN_ID2( zporfs, ZPORFS ) + +// Value-type variants of potrf +#define LAPACK_SPOTRF FORTRAN_ID2( spotrf, SPOTRF ) +#define LAPACK_DPOTRF FORTRAN_ID2( dpotrf, DPOTRF ) +#define LAPACK_CPOTRF FORTRAN_ID2( cpotrf, CPOTRF ) +#define LAPACK_ZPOTRF FORTRAN_ID2( zpotrf, ZPOTRF ) + +// Value-type variants of potri +#define LAPACK_SPOTRI FORTRAN_ID2( spotri, SPOTRI ) +#define LAPACK_DPOTRI FORTRAN_ID2( dpotri, DPOTRI ) +#define LAPACK_CPOTRI FORTRAN_ID2( cpotri, CPOTRI ) +#define LAPACK_ZPOTRI FORTRAN_ID2( zpotri, ZPOTRI ) + +// Value-type variants of potrs +#define LAPACK_SPOTRS FORTRAN_ID2( spotrs, SPOTRS ) +#define LAPACK_DPOTRS FORTRAN_ID2( dpotrs, DPOTRS ) +#define LAPACK_CPOTRS FORTRAN_ID2( cpotrs, CPOTRS ) +#define LAPACK_ZPOTRS FORTRAN_ID2( zpotrs, ZPOTRS ) + +// Value-type variants of ppcon +#define LAPACK_SPPCON FORTRAN_ID2( sppcon, SPPCON ) +#define LAPACK_DPPCON FORTRAN_ID2( dppcon, DPPCON ) +#define LAPACK_CPPCON FORTRAN_ID2( cppcon, CPPCON ) +#define LAPACK_ZPPCON FORTRAN_ID2( zppcon, ZPPCON ) + +// Value-type variants of ppequ +#define LAPACK_SPPEQU FORTRAN_ID2( sppequ, SPPEQU ) +#define LAPACK_DPPEQU FORTRAN_ID2( dppequ, DPPEQU ) +#define LAPACK_CPPEQU FORTRAN_ID2( cppequ, CPPEQU ) +#define LAPACK_ZPPEQU FORTRAN_ID2( zppequ, ZPPEQU ) + +// Value-type variants of pprfs +#define LAPACK_SPPRFS FORTRAN_ID2( spprfs, SPPRFS ) +#define LAPACK_DPPRFS FORTRAN_ID2( dpprfs, DPPRFS ) +#define LAPACK_CPPRFS FORTRAN_ID2( cpprfs, CPPRFS ) +#define LAPACK_ZPPRFS FORTRAN_ID2( zpprfs, ZPPRFS ) + +// Value-type variants of pptrf +#define LAPACK_SPPTRF FORTRAN_ID2( spptrf, SPPTRF ) +#define LAPACK_DPPTRF FORTRAN_ID2( dpptrf, DPPTRF ) +#define LAPACK_CPPTRF FORTRAN_ID2( cpptrf, CPPTRF ) +#define LAPACK_ZPPTRF FORTRAN_ID2( zpptrf, ZPPTRF ) + +// Value-type variants of pptri +#define LAPACK_SPPTRI FORTRAN_ID2( spptri, SPPTRI ) +#define LAPACK_DPPTRI FORTRAN_ID2( dpptri, DPPTRI ) +#define LAPACK_CPPTRI FORTRAN_ID2( cpptri, CPPTRI ) +#define LAPACK_ZPPTRI FORTRAN_ID2( zpptri, ZPPTRI ) + +// Value-type variants of pptrs +#define LAPACK_SPPTRS FORTRAN_ID2( spptrs, SPPTRS ) +#define LAPACK_DPPTRS FORTRAN_ID2( dpptrs, DPPTRS ) +#define LAPACK_CPPTRS FORTRAN_ID2( cpptrs, CPPTRS ) +#define LAPACK_ZPPTRS FORTRAN_ID2( zpptrs, ZPPTRS ) + +// Value-type variants of pstrf +#define LAPACK_SPSTRF FORTRAN_ID2( spstrf, SPSTRF ) +#define LAPACK_DPSTRF FORTRAN_ID2( dpstrf, DPSTRF ) +#define LAPACK_CPSTRF FORTRAN_ID2( cpstrf, CPSTRF ) +#define LAPACK_ZPSTRF FORTRAN_ID2( zpstrf, ZPSTRF ) + +// Value-type variants of ptcon +#define LAPACK_SPTCON FORTRAN_ID2( sptcon, SPTCON ) +#define LAPACK_DPTCON FORTRAN_ID2( dptcon, DPTCON ) +#define LAPACK_CPTCON FORTRAN_ID2( cptcon, CPTCON ) +#define LAPACK_ZPTCON FORTRAN_ID2( zptcon, ZPTCON ) + +// Value-type variants of ptrfs +#define LAPACK_SPTRFS FORTRAN_ID2( sptrfs, SPTRFS ) +#define LAPACK_DPTRFS FORTRAN_ID2( dptrfs, DPTRFS ) +#define LAPACK_CPTRFS FORTRAN_ID2( cptrfs, CPTRFS ) +#define LAPACK_ZPTRFS FORTRAN_ID2( zptrfs, ZPTRFS ) + +// Value-type variants of pttrf +#define LAPACK_SPTTRF FORTRAN_ID2( spttrf, SPTTRF ) +#define LAPACK_DPTTRF FORTRAN_ID2( dpttrf, DPTTRF ) +#define LAPACK_CPTTRF FORTRAN_ID2( cpttrf, CPTTRF ) +#define LAPACK_ZPTTRF FORTRAN_ID2( zpttrf, ZPTTRF ) + +// Value-type variants of pttrs +#define LAPACK_SPTTRS FORTRAN_ID2( spttrs, SPTTRS ) +#define LAPACK_DPTTRS FORTRAN_ID2( dpttrs, DPTTRS ) +#define LAPACK_CPTTRS FORTRAN_ID2( cpttrs, CPTTRS ) +#define LAPACK_ZPTTRS FORTRAN_ID2( zpttrs, ZPTTRS ) + +// Value-type variants of spcon +#define LAPACK_SSPCON FORTRAN_ID2( sspcon, SSPCON ) +#define LAPACK_DSPCON FORTRAN_ID2( dspcon, DSPCON ) +#define LAPACK_CSPCON FORTRAN_ID2( cspcon, CSPCON ) +#define LAPACK_ZSPCON FORTRAN_ID2( zspcon, ZSPCON ) + +// Value-type variants of sprfs +#define LAPACK_SSPRFS FORTRAN_ID2( ssprfs, SSPRFS ) +#define LAPACK_DSPRFS FORTRAN_ID2( dsprfs, DSPRFS ) +#define LAPACK_CSPRFS FORTRAN_ID2( csprfs, CSPRFS ) +#define LAPACK_ZSPRFS FORTRAN_ID2( zsprfs, ZSPRFS ) + +// Value-type variants of sptrf +#define LAPACK_SSPTRF FORTRAN_ID2( ssptrf, SSPTRF ) +#define LAPACK_DSPTRF FORTRAN_ID2( dsptrf, DSPTRF ) +#define LAPACK_CSPTRF FORTRAN_ID2( csptrf, CSPTRF ) +#define LAPACK_ZSPTRF FORTRAN_ID2( zsptrf, ZSPTRF ) + +// Value-type variants of sptri +#define LAPACK_SSPTRI FORTRAN_ID2( ssptri, SSPTRI ) +#define LAPACK_DSPTRI FORTRAN_ID2( dsptri, DSPTRI ) +#define LAPACK_CSPTRI FORTRAN_ID2( csptri, CSPTRI ) +#define LAPACK_ZSPTRI FORTRAN_ID2( zsptri, ZSPTRI ) + +// Value-type variants of sptrs +#define LAPACK_SSPTRS FORTRAN_ID2( ssptrs, SSPTRS ) +#define LAPACK_DSPTRS FORTRAN_ID2( dsptrs, DSPTRS ) +#define LAPACK_CSPTRS FORTRAN_ID2( csptrs, CSPTRS ) +#define LAPACK_ZSPTRS FORTRAN_ID2( zsptrs, ZSPTRS ) + +// Value-type variants of sycon +#define LAPACK_SSYCON FORTRAN_ID2( ssycon, SSYCON ) +#define LAPACK_DSYCON FORTRAN_ID2( dsycon, DSYCON ) +#define LAPACK_CSYCON FORTRAN_ID2( csycon, CSYCON ) +#define LAPACK_ZSYCON FORTRAN_ID2( zsycon, ZSYCON ) + +// Value-type variants of syrfs +#define LAPACK_SSYRFS FORTRAN_ID2( ssyrfs, SSYRFS ) +#define LAPACK_DSYRFS FORTRAN_ID2( dsyrfs, DSYRFS ) +#define LAPACK_CSYRFS FORTRAN_ID2( csyrfs, CSYRFS ) +#define LAPACK_ZSYRFS FORTRAN_ID2( zsyrfs, ZSYRFS ) + +// Value-type variants of sytrf +#define LAPACK_SSYTRF FORTRAN_ID2( ssytrf, SSYTRF ) +#define LAPACK_DSYTRF FORTRAN_ID2( dsytrf, DSYTRF ) +#define LAPACK_CSYTRF FORTRAN_ID2( csytrf, CSYTRF ) +#define LAPACK_ZSYTRF FORTRAN_ID2( zsytrf, ZSYTRF ) + +// Value-type variants of sytri +#define LAPACK_SSYTRI FORTRAN_ID2( ssytri, SSYTRI ) +#define LAPACK_DSYTRI FORTRAN_ID2( dsytri, DSYTRI ) +#define LAPACK_CSYTRI FORTRAN_ID2( csytri, CSYTRI ) +#define LAPACK_ZSYTRI FORTRAN_ID2( zsytri, ZSYTRI ) + +// Value-type variants of sytrs +#define LAPACK_SSYTRS FORTRAN_ID2( ssytrs, SSYTRS ) +#define LAPACK_DSYTRS FORTRAN_ID2( dsytrs, DSYTRS ) +#define LAPACK_CSYTRS FORTRAN_ID2( csytrs, CSYTRS ) +#define LAPACK_ZSYTRS FORTRAN_ID2( zsytrs, ZSYTRS ) + +// Value-type variants of tbcon +#define LAPACK_STBCON FORTRAN_ID2( stbcon, STBCON ) +#define LAPACK_DTBCON FORTRAN_ID2( dtbcon, DTBCON ) +#define LAPACK_CTBCON FORTRAN_ID2( ctbcon, CTBCON ) +#define LAPACK_ZTBCON FORTRAN_ID2( ztbcon, ZTBCON ) + +// Value-type variants of tbrfs +#define LAPACK_STBRFS FORTRAN_ID2( stbrfs, STBRFS ) +#define LAPACK_DTBRFS FORTRAN_ID2( dtbrfs, DTBRFS ) +#define LAPACK_CTBRFS FORTRAN_ID2( ctbrfs, CTBRFS ) +#define LAPACK_ZTBRFS FORTRAN_ID2( ztbrfs, ZTBRFS ) + +// Value-type variants of tbtrs +#define LAPACK_STBTRS FORTRAN_ID2( stbtrs, STBTRS ) +#define LAPACK_DTBTRS FORTRAN_ID2( dtbtrs, DTBTRS ) +#define LAPACK_CTBTRS FORTRAN_ID2( ctbtrs, CTBTRS ) +#define LAPACK_ZTBTRS FORTRAN_ID2( ztbtrs, ZTBTRS ) + +// Value-type variants of tftri +#define LAPACK_STFTRI FORTRAN_ID2( stftri, STFTRI ) +#define LAPACK_DTFTRI FORTRAN_ID2( dtftri, DTFTRI ) +#define LAPACK_CTFTRI FORTRAN_ID2( ctftri, CTFTRI ) +#define LAPACK_ZTFTRI FORTRAN_ID2( ztftri, ZTFTRI ) + +// Value-type variants of tpcon +#define LAPACK_STPCON FORTRAN_ID2( stpcon, STPCON ) +#define LAPACK_DTPCON FORTRAN_ID2( dtpcon, DTPCON ) +#define LAPACK_CTPCON FORTRAN_ID2( ctpcon, CTPCON ) +#define LAPACK_ZTPCON FORTRAN_ID2( ztpcon, ZTPCON ) + +// Value-type variants of tprfs +#define LAPACK_STPRFS FORTRAN_ID2( stprfs, STPRFS ) +#define LAPACK_DTPRFS FORTRAN_ID2( dtprfs, DTPRFS ) +#define LAPACK_CTPRFS FORTRAN_ID2( ctprfs, CTPRFS ) +#define LAPACK_ZTPRFS FORTRAN_ID2( ztprfs, ZTPRFS ) + +// Value-type variants of tptri +#define LAPACK_STPTRI FORTRAN_ID2( stptri, STPTRI ) +#define LAPACK_DTPTRI FORTRAN_ID2( dtptri, DTPTRI ) +#define LAPACK_CTPTRI FORTRAN_ID2( ctptri, CTPTRI ) +#define LAPACK_ZTPTRI FORTRAN_ID2( ztptri, ZTPTRI ) + +// Value-type variants of tptrs +#define LAPACK_STPTRS FORTRAN_ID2( stptrs, STPTRS ) +#define LAPACK_DTPTRS FORTRAN_ID2( dtptrs, DTPTRS ) +#define LAPACK_CTPTRS FORTRAN_ID2( ctptrs, CTPTRS ) +#define LAPACK_ZTPTRS FORTRAN_ID2( ztptrs, ZTPTRS ) + +// Value-type variants of trcon +#define LAPACK_STRCON FORTRAN_ID2( strcon, STRCON ) +#define LAPACK_DTRCON FORTRAN_ID2( dtrcon, DTRCON ) +#define LAPACK_CTRCON FORTRAN_ID2( ctrcon, CTRCON ) +#define LAPACK_ZTRCON FORTRAN_ID2( ztrcon, ZTRCON ) + +// Value-type variants of trrfs +#define LAPACK_STRRFS FORTRAN_ID2( strrfs, STRRFS ) +#define LAPACK_DTRRFS FORTRAN_ID2( dtrrfs, DTRRFS ) +#define LAPACK_CTRRFS FORTRAN_ID2( ctrrfs, CTRRFS ) +#define LAPACK_ZTRRFS FORTRAN_ID2( ztrrfs, ZTRRFS ) + +// Value-type variants of trtri +#define LAPACK_STRTRI FORTRAN_ID2( strtri, STRTRI ) +#define LAPACK_DTRTRI FORTRAN_ID2( dtrtri, DTRTRI ) +#define LAPACK_CTRTRI FORTRAN_ID2( ctrtri, CTRTRI ) +#define LAPACK_ZTRTRI FORTRAN_ID2( ztrtri, ZTRTRI ) + +// Value-type variants of trtrs +#define LAPACK_STRTRS FORTRAN_ID2( strtrs, STRTRS ) +#define LAPACK_DTRTRS FORTRAN_ID2( dtrtrs, DTRTRS ) +#define LAPACK_CTRTRS FORTRAN_ID2( ctrtrs, CTRTRS ) +#define LAPACK_ZTRTRS FORTRAN_ID2( ztrtrs, ZTRTRS ) + +// Value-type variants of hbtrd +#define LAPACK_CHBTRD FORTRAN_ID2( chbtrd, CHBTRD ) +#define LAPACK_ZHBTRD FORTRAN_ID2( zhbtrd, ZHBTRD ) + +// Value-type variants of hetrd +#define LAPACK_CHETRD FORTRAN_ID2( chetrd, CHETRD ) +#define LAPACK_ZHETRD FORTRAN_ID2( zhetrd, ZHETRD ) + +// Value-type variants of hptrd +#define LAPACK_CHPTRD FORTRAN_ID2( chptrd, CHPTRD ) +#define LAPACK_ZHPTRD FORTRAN_ID2( zhptrd, ZHPTRD ) + +// Value-type variants of opgtr +#define LAPACK_SOPGTR FORTRAN_ID2( sopgtr, SOPGTR ) +#define LAPACK_DOPGTR FORTRAN_ID2( dopgtr, DOPGTR ) + +// Value-type variants of opmtr +#define LAPACK_SOPMTR FORTRAN_ID2( sopmtr, SOPMTR ) +#define LAPACK_DOPMTR FORTRAN_ID2( dopmtr, DOPMTR ) + +// Value-type variants of orgtr +#define LAPACK_SORGTR FORTRAN_ID2( sorgtr, SORGTR ) +#define LAPACK_DORGTR FORTRAN_ID2( dorgtr, DORGTR ) + +// Value-type variants of ormtr +#define LAPACK_SORMTR FORTRAN_ID2( sormtr, SORMTR ) +#define LAPACK_DORMTR FORTRAN_ID2( dormtr, DORMTR ) + +// Value-type variants of pteqr +#define LAPACK_SPTEQR FORTRAN_ID2( spteqr, SPTEQR ) +#define LAPACK_DPTEQR FORTRAN_ID2( dpteqr, DPTEQR ) +#define LAPACK_CPTEQR FORTRAN_ID2( cpteqr, CPTEQR ) +#define LAPACK_ZPTEQR FORTRAN_ID2( zpteqr, ZPTEQR ) + +// Value-type variants of sbtrd +#define LAPACK_SSBTRD FORTRAN_ID2( ssbtrd, SSBTRD ) +#define LAPACK_DSBTRD FORTRAN_ID2( dsbtrd, DSBTRD ) + +// Value-type variants of sptrd +#define LAPACK_SSPTRD FORTRAN_ID2( ssptrd, SSPTRD ) +#define LAPACK_DSPTRD FORTRAN_ID2( dsptrd, DSPTRD ) + +// Value-type variants of stebz +#define LAPACK_SSTEBZ FORTRAN_ID2( sstebz, SSTEBZ ) +#define LAPACK_DSTEBZ FORTRAN_ID2( dstebz, DSTEBZ ) + +// Value-type variants of stedc +#define LAPACK_SSTEDC FORTRAN_ID2( sstedc, SSTEDC ) +#define LAPACK_DSTEDC FORTRAN_ID2( dstedc, DSTEDC ) +#define LAPACK_CSTEDC FORTRAN_ID2( cstedc, CSTEDC ) +#define LAPACK_ZSTEDC FORTRAN_ID2( zstedc, ZSTEDC ) + +// Value-type variants of stegr +#define LAPACK_SSTEGR FORTRAN_ID2( sstegr, SSTEGR ) +#define LAPACK_DSTEGR FORTRAN_ID2( dstegr, DSTEGR ) +#define LAPACK_CSTEGR FORTRAN_ID2( cstegr, CSTEGR ) +#define LAPACK_ZSTEGR FORTRAN_ID2( zstegr, ZSTEGR ) + +// Value-type variants of stein +#define LAPACK_SSTEIN FORTRAN_ID2( sstein, SSTEIN ) +#define LAPACK_DSTEIN FORTRAN_ID2( dstein, DSTEIN ) +#define LAPACK_CSTEIN FORTRAN_ID2( cstein, CSTEIN ) +#define LAPACK_ZSTEIN FORTRAN_ID2( zstein, ZSTEIN ) + +// Value-type variants of stemr +#define LAPACK_SSTEMR FORTRAN_ID2( sstemr, SSTEMR ) +#define LAPACK_DSTEMR FORTRAN_ID2( dstemr, DSTEMR ) +#define LAPACK_CSTEMR FORTRAN_ID2( cstemr, CSTEMR ) +#define LAPACK_ZSTEMR FORTRAN_ID2( zstemr, ZSTEMR ) + +// Value-type variants of steqr +#define LAPACK_SSTEQR FORTRAN_ID2( ssteqr, SSTEQR ) +#define LAPACK_DSTEQR FORTRAN_ID2( dsteqr, DSTEQR ) +#define LAPACK_CSTEQR FORTRAN_ID2( csteqr, CSTEQR ) +#define LAPACK_ZSTEQR FORTRAN_ID2( zsteqr, ZSTEQR ) + +// Value-type variants of sterf +#define LAPACK_SSTERF FORTRAN_ID2( ssterf, SSTERF ) +#define LAPACK_DSTERF FORTRAN_ID2( dsterf, DSTERF ) + +// Value-type variants of sytrd +#define LAPACK_SSYTRD FORTRAN_ID2( ssytrd, SSYTRD ) +#define LAPACK_DSYTRD FORTRAN_ID2( dsytrd, DSYTRD ) + +// Value-type variants of ungtr +#define LAPACK_CUNGTR FORTRAN_ID2( cungtr, CUNGTR ) +#define LAPACK_ZUNGTR FORTRAN_ID2( zungtr, ZUNGTR ) + +// Value-type variants of unmtr +#define LAPACK_CUNMTR FORTRAN_ID2( cunmtr, CUNMTR ) +#define LAPACK_ZUNMTR FORTRAN_ID2( zunmtr, ZUNMTR ) + +// Value-type variants of upgtr +#define LAPACK_CUPGTR FORTRAN_ID2( cupgtr, CUPGTR ) +#define LAPACK_ZUPGTR FORTRAN_ID2( zupgtr, ZUPGTR ) + +// Value-type variants of upmtr +#define LAPACK_CUPMTR FORTRAN_ID2( cupmtr, CUPMTR ) +#define LAPACK_ZUPMTR FORTRAN_ID2( zupmtr, ZUPMTR ) + +// Value-type variants of ggbak +#define LAPACK_SGGBAK FORTRAN_ID2( sggbak, SGGBAK ) +#define LAPACK_DGGBAK FORTRAN_ID2( dggbak, DGGBAK ) +#define LAPACK_CGGBAK FORTRAN_ID2( cggbak, CGGBAK ) +#define LAPACK_ZGGBAK FORTRAN_ID2( zggbak, ZGGBAK ) + +// Value-type variants of ggbal +#define LAPACK_SGGBAL FORTRAN_ID2( sggbal, SGGBAL ) +#define LAPACK_DGGBAL FORTRAN_ID2( dggbal, DGGBAL ) +#define LAPACK_CGGBAL FORTRAN_ID2( cggbal, CGGBAL ) +#define LAPACK_ZGGBAL FORTRAN_ID2( zggbal, ZGGBAL ) + +// Value-type variants of gghrd +#define LAPACK_SGGHRD FORTRAN_ID2( sgghrd, SGGHRD ) +#define LAPACK_DGGHRD FORTRAN_ID2( dgghrd, DGGHRD ) +#define LAPACK_CGGHRD FORTRAN_ID2( cgghrd, CGGHRD ) +#define LAPACK_ZGGHRD FORTRAN_ID2( zgghrd, ZGGHRD ) + +// Value-type variants of hgeqz +#define LAPACK_SHGEQZ FORTRAN_ID2( shgeqz, SHGEQZ ) +#define LAPACK_DHGEQZ FORTRAN_ID2( dhgeqz, DHGEQZ ) +#define LAPACK_CHGEQZ FORTRAN_ID2( chgeqz, CHGEQZ ) +#define LAPACK_ZHGEQZ FORTRAN_ID2( zhgeqz, ZHGEQZ ) + +// Value-type variants of tgevc +#define LAPACK_STGEVC FORTRAN_ID2( stgevc, STGEVC ) +#define LAPACK_DTGEVC FORTRAN_ID2( dtgevc, DTGEVC ) +#define LAPACK_CTGEVC FORTRAN_ID2( ctgevc, CTGEVC ) +#define LAPACK_ZTGEVC FORTRAN_ID2( ztgevc, ZTGEVC ) + +// Value-type variants of tgexc +#define LAPACK_STGEXC FORTRAN_ID2( stgexc, STGEXC ) +#define LAPACK_DTGEXC FORTRAN_ID2( dtgexc, DTGEXC ) +#define LAPACK_CTGEXC FORTRAN_ID2( ctgexc, CTGEXC ) +#define LAPACK_ZTGEXC FORTRAN_ID2( ztgexc, ZTGEXC ) + +// Value-type variants of tgsen +#define LAPACK_STGSEN FORTRAN_ID2( stgsen, STGSEN ) +#define LAPACK_DTGSEN FORTRAN_ID2( dtgsen, DTGSEN ) +#define LAPACK_CTGSEN FORTRAN_ID2( ctgsen, CTGSEN ) +#define LAPACK_ZTGSEN FORTRAN_ID2( ztgsen, ZTGSEN ) + +// Value-type variants of tgsna +#define LAPACK_STGSNA FORTRAN_ID2( stgsna, STGSNA ) +#define LAPACK_DTGSNA FORTRAN_ID2( dtgsna, DTGSNA ) +#define LAPACK_CTGSNA FORTRAN_ID2( ctgsna, CTGSNA ) +#define LAPACK_ZTGSNA FORTRAN_ID2( ztgsna, ZTGSNA ) + +// Value-type variants of tgsyl +#define LAPACK_STGSYL FORTRAN_ID2( stgsyl, STGSYL ) +#define LAPACK_DTGSYL FORTRAN_ID2( dtgsyl, DTGSYL ) +#define LAPACK_CTGSYL FORTRAN_ID2( ctgsyl, CTGSYL ) +#define LAPACK_ZTGSYL FORTRAN_ID2( ztgsyl, ZTGSYL ) + +// Value-type variants of ggsvp +#define LAPACK_SGGSVP FORTRAN_ID2( sggsvp, SGGSVP ) +#define LAPACK_DGGSVP FORTRAN_ID2( dggsvp, DGGSVP ) +#define LAPACK_CGGSVP FORTRAN_ID2( cggsvp, CGGSVP ) +#define LAPACK_ZGGSVP FORTRAN_ID2( zggsvp, ZGGSVP ) + +// Value-type variants of tgsja +#define LAPACK_STGSJA FORTRAN_ID2( stgsja, STGSJA ) +#define LAPACK_DTGSJA FORTRAN_ID2( dtgsja, DTGSJA ) +#define LAPACK_CTGSJA FORTRAN_ID2( ctgsja, CTGSJA ) +#define LAPACK_ZTGSJA FORTRAN_ID2( ztgsja, ZTGSJA ) + +// +// LAPACK driver routines +// + +// Value-type variants of gegv +#define LAPACK_SGEGV FORTRAN_ID2( sgegv, SGEGV ) +#define LAPACK_DGEGV FORTRAN_ID2( dgegv, DGEGV ) +#define LAPACK_CGEGV FORTRAN_ID2( cgegv, CGEGV ) +#define LAPACK_ZGEGV FORTRAN_ID2( zgegv, ZGEGV ) + +// Value-type variants of gges +#define LAPACK_SGGES FORTRAN_ID2( sgges, SGGES ) +#define LAPACK_DGGES FORTRAN_ID2( dgges, DGGES ) +#define LAPACK_CGGES FORTRAN_ID2( cgges, CGGES ) +#define LAPACK_ZGGES FORTRAN_ID2( zgges, ZGGES ) + +// Value-type variants of ggesx +#define LAPACK_SGGESX FORTRAN_ID2( sggesx, SGGESX ) +#define LAPACK_DGGESX FORTRAN_ID2( dggesx, DGGESX ) +#define LAPACK_CGGESX FORTRAN_ID2( cggesx, CGGESX ) +#define LAPACK_ZGGESX FORTRAN_ID2( zggesx, ZGGESX ) + +// Value-type variants of ggev +#define LAPACK_SGGEV FORTRAN_ID2( sggev, SGGEV ) +#define LAPACK_DGGEV FORTRAN_ID2( dggev, DGGEV ) +#define LAPACK_CGGEV FORTRAN_ID2( cggev, CGGEV ) +#define LAPACK_ZGGEV FORTRAN_ID2( zggev, ZGGEV ) + +// Value-type variants of ggevx +#define LAPACK_SGGEVX FORTRAN_ID2( sggevx, SGGEVX ) +#define LAPACK_DGGEVX FORTRAN_ID2( dggevx, DGGEVX ) +#define LAPACK_CGGEVX FORTRAN_ID2( cggevx, CGGEVX ) +#define LAPACK_ZGGEVX FORTRAN_ID2( zggevx, ZGGEVX ) + +// Value-type variants of ggsvd +#define LAPACK_SGGSVD FORTRAN_ID2( sggsvd, SGGSVD ) +#define LAPACK_DGGSVD FORTRAN_ID2( dggsvd, DGGSVD ) +#define LAPACK_CGGSVD FORTRAN_ID2( cggsvd, CGGSVD ) +#define LAPACK_ZGGSVD FORTRAN_ID2( zggsvd, ZGGSVD ) + +// Value-type variants of hbgv +#define LAPACK_CHBGV FORTRAN_ID2( chbgv, CHBGV ) +#define LAPACK_ZHBGV FORTRAN_ID2( zhbgv, ZHBGV ) + +// Value-type variants of hbgvd +#define LAPACK_CHBGVD FORTRAN_ID2( chbgvd, CHBGVD ) +#define LAPACK_ZHBGVD FORTRAN_ID2( zhbgvd, ZHBGVD ) + +// Value-type variants of hbgvx +#define LAPACK_CHBGVX FORTRAN_ID2( chbgvx, CHBGVX ) +#define LAPACK_ZHBGVX FORTRAN_ID2( zhbgvx, ZHBGVX ) + +// Value-type variants of hegv +#define LAPACK_CHEGV FORTRAN_ID2( chegv, CHEGV ) +#define LAPACK_ZHEGV FORTRAN_ID2( zhegv, ZHEGV ) + +// Value-type variants of hegvd +#define LAPACK_CHEGVD FORTRAN_ID2( chegvd, CHEGVD ) +#define LAPACK_ZHEGVD FORTRAN_ID2( zhegvd, ZHEGVD ) + +// Value-type variants of hegvx +#define LAPACK_CHEGVX FORTRAN_ID2( chegvx, CHEGVX ) +#define LAPACK_ZHEGVX FORTRAN_ID2( zhegvx, ZHEGVX ) + +// Value-type variants of hpgv +#define LAPACK_CHPGV FORTRAN_ID2( chpgv, CHPGV ) +#define LAPACK_ZHPGV FORTRAN_ID2( zhpgv, ZHPGV ) + +// Value-type variants of hpgvd +#define LAPACK_CHPGVD FORTRAN_ID2( chpgvd, CHPGVD ) +#define LAPACK_ZHPGVD FORTRAN_ID2( zhpgvd, ZHPGVD ) + +// Value-type variants of hpgvx +#define LAPACK_CHPGVX FORTRAN_ID2( chpgvx, CHPGVX ) +#define LAPACK_ZHPGVX FORTRAN_ID2( zhpgvx, ZHPGVX ) + +// Value-type variants of sbgv +#define LAPACK_SSBGV FORTRAN_ID2( ssbgv, SSBGV ) +#define LAPACK_DSBGV FORTRAN_ID2( dsbgv, DSBGV ) + +// Value-type variants of sbgvd +#define LAPACK_SSBGVD FORTRAN_ID2( ssbgvd, SSBGVD ) +#define LAPACK_DSBGVD FORTRAN_ID2( dsbgvd, DSBGVD ) + +// Value-type variants of sbgvx +#define LAPACK_SSBGVX FORTRAN_ID2( ssbgvx, SSBGVX ) +#define LAPACK_DSBGVX FORTRAN_ID2( dsbgvx, DSBGVX ) + +// Value-type variants of spgv +#define LAPACK_SSPGV FORTRAN_ID2( sspgv, SSPGV ) +#define LAPACK_DSPGV FORTRAN_ID2( dspgv, DSPGV ) + +// Value-type variants of spgvd +#define LAPACK_SSPGVD FORTRAN_ID2( sspgvd, SSPGVD ) +#define LAPACK_DSPGVD FORTRAN_ID2( dspgvd, DSPGVD ) + +// Value-type variants of spgvx +#define LAPACK_SSPGVX FORTRAN_ID2( sspgvx, SSPGVX ) +#define LAPACK_DSPGVX FORTRAN_ID2( dspgvx, DSPGVX ) + +// Value-type variants of sygv +#define LAPACK_SSYGV FORTRAN_ID2( ssygv, SSYGV ) +#define LAPACK_DSYGV FORTRAN_ID2( dsygv, DSYGV ) + +// Value-type variants of sygvd +#define LAPACK_SSYGVD FORTRAN_ID2( ssygvd, SSYGVD ) +#define LAPACK_DSYGVD FORTRAN_ID2( dsygvd, DSYGVD ) + +// Value-type variants of sygvx +#define LAPACK_SSYGVX FORTRAN_ID2( ssygvx, SSYGVX ) +#define LAPACK_DSYGVX FORTRAN_ID2( dsygvx, DSYGVX ) + +// Value-type variants of ggglm +#define LAPACK_SGGGLM FORTRAN_ID2( sggglm, SGGGLM ) +#define LAPACK_DGGGLM FORTRAN_ID2( dggglm, DGGGLM ) +#define LAPACK_CGGGLM FORTRAN_ID2( cggglm, CGGGLM ) +#define LAPACK_ZGGGLM FORTRAN_ID2( zggglm, ZGGGLM ) + +// Value-type variants of gglse +#define LAPACK_SGGLSE FORTRAN_ID2( sgglse, SGGLSE ) +#define LAPACK_DGGLSE FORTRAN_ID2( dgglse, DGGLSE ) +#define LAPACK_CGGLSE FORTRAN_ID2( cgglse, CGGLSE ) +#define LAPACK_ZGGLSE FORTRAN_ID2( zgglse, ZGGLSE ) + +// Value-type variants of gbsv +#define LAPACK_SGBSV FORTRAN_ID2( sgbsv, SGBSV ) +#define LAPACK_DGBSV FORTRAN_ID2( dgbsv, DGBSV ) +#define LAPACK_CGBSV FORTRAN_ID2( cgbsv, CGBSV ) +#define LAPACK_ZGBSV FORTRAN_ID2( zgbsv, ZGBSV ) + +// Value-type variants of gbsvx +#define LAPACK_SGBSVX FORTRAN_ID2( sgbsvx, SGBSVX ) +#define LAPACK_DGBSVX FORTRAN_ID2( dgbsvx, DGBSVX ) +#define LAPACK_CGBSVX FORTRAN_ID2( cgbsvx, CGBSVX ) +#define LAPACK_ZGBSVX FORTRAN_ID2( zgbsvx, ZGBSVX ) + +// Value-type variants of gejsv +#define LAPACK_SGEJSV FORTRAN_ID2( sgejsv, SGEJSV ) +#define LAPACK_DGEJSV FORTRAN_ID2( dgejsv, DGEJSV ) + +// Value-type variants of gesv +#define LAPACK_SGESV FORTRAN_ID2( sgesv, SGESV ) +#define LAPACK_DGESV FORTRAN_ID2( dgesv, DGESV ) +#define LAPACK_CGESV FORTRAN_ID2( cgesv, CGESV ) +#define LAPACK_ZGESV FORTRAN_ID2( zgesv, ZGESV ) + +// Value-type variants of gesvx +#define LAPACK_SGESVX FORTRAN_ID2( sgesvx, SGESVX ) +#define LAPACK_DGESVX FORTRAN_ID2( dgesvx, DGESVX ) +#define LAPACK_CGESVX FORTRAN_ID2( cgesvx, CGESVX ) +#define LAPACK_ZGESVX FORTRAN_ID2( zgesvx, ZGESVX ) + +// Value-type variants of gtsv +#define LAPACK_SGTSV FORTRAN_ID2( sgtsv, SGTSV ) +#define LAPACK_DGTSV FORTRAN_ID2( dgtsv, DGTSV ) +#define LAPACK_CGTSV FORTRAN_ID2( cgtsv, CGTSV ) +#define LAPACK_ZGTSV FORTRAN_ID2( zgtsv, ZGTSV ) + +// Value-type variants of gtsvx +#define LAPACK_SGTSVX FORTRAN_ID2( sgtsvx, SGTSVX ) +#define LAPACK_DGTSVX FORTRAN_ID2( dgtsvx, DGTSVX ) +#define LAPACK_CGTSVX FORTRAN_ID2( cgtsvx, CGTSVX ) +#define LAPACK_ZGTSVX FORTRAN_ID2( zgtsvx, ZGTSVX ) + +// Value-type variants of hesv +#define LAPACK_CHESV FORTRAN_ID2( chesv, CHESV ) +#define LAPACK_ZHESV FORTRAN_ID2( zhesv, ZHESV ) + +// Value-type variants of hesvx +#define LAPACK_CHESVX FORTRAN_ID2( chesvx, CHESVX ) +#define LAPACK_ZHESVX FORTRAN_ID2( zhesvx, ZHESVX ) + +// Value-type variants of hpsv +#define LAPACK_CHPSV FORTRAN_ID2( chpsv, CHPSV ) +#define LAPACK_ZHPSV FORTRAN_ID2( zhpsv, ZHPSV ) + +// Value-type variants of hpsvx +#define LAPACK_CHPSVX FORTRAN_ID2( chpsvx, CHPSVX ) +#define LAPACK_ZHPSVX FORTRAN_ID2( zhpsvx, ZHPSVX ) + +// Value-type variants of iter_gesv +#define LAPACK_DSGESV FORTRAN_ID2( dsgesv, DSGESV ) +#define LAPACK_ZCGESV FORTRAN_ID2( zcgesv, ZCGESV ) + +// Value-type variants of iter_posv +#define LAPACK_DSPOSV FORTRAN_ID2( dsposv, DSPOSV ) +#define LAPACK_ZCPOSV FORTRAN_ID2( zcposv, ZCPOSV ) + +// Value-type variants of pbsv +#define LAPACK_SPBSV FORTRAN_ID2( spbsv, SPBSV ) +#define LAPACK_DPBSV FORTRAN_ID2( dpbsv, DPBSV ) +#define LAPACK_CPBSV FORTRAN_ID2( cpbsv, CPBSV ) +#define LAPACK_ZPBSV FORTRAN_ID2( zpbsv, ZPBSV ) + +// Value-type variants of pbsvx +#define LAPACK_SPBSVX FORTRAN_ID2( spbsvx, SPBSVX ) +#define LAPACK_DPBSVX FORTRAN_ID2( dpbsvx, DPBSVX ) +#define LAPACK_CPBSVX FORTRAN_ID2( cpbsvx, CPBSVX ) +#define LAPACK_ZPBSVX FORTRAN_ID2( zpbsvx, ZPBSVX ) + +// Value-type variants of posv +#define LAPACK_SPOSV FORTRAN_ID2( sposv, SPOSV ) +#define LAPACK_DPOSV FORTRAN_ID2( dposv, DPOSV ) +#define LAPACK_CPOSV FORTRAN_ID2( cposv, CPOSV ) +#define LAPACK_ZPOSV FORTRAN_ID2( zposv, ZPOSV ) + +// Value-type variants of posvx +#define LAPACK_SPOSVX FORTRAN_ID2( sposvx, SPOSVX ) +#define LAPACK_DPOSVX FORTRAN_ID2( dposvx, DPOSVX ) +#define LAPACK_CPOSVX FORTRAN_ID2( cposvx, CPOSVX ) +#define LAPACK_ZPOSVX FORTRAN_ID2( zposvx, ZPOSVX ) + +// Value-type variants of ppsv +#define LAPACK_SPPSV FORTRAN_ID2( sppsv, SPPSV ) +#define LAPACK_DPPSV FORTRAN_ID2( dppsv, DPPSV ) +#define LAPACK_CPPSV FORTRAN_ID2( cppsv, CPPSV ) +#define LAPACK_ZPPSV FORTRAN_ID2( zppsv, ZPPSV ) + +// Value-type variants of ppsvx +#define LAPACK_SPPSVX FORTRAN_ID2( sppsvx, SPPSVX ) +#define LAPACK_DPPSVX FORTRAN_ID2( dppsvx, DPPSVX ) +#define LAPACK_CPPSVX FORTRAN_ID2( cppsvx, CPPSVX ) +#define LAPACK_ZPPSVX FORTRAN_ID2( zppsvx, ZPPSVX ) + +// Value-type variants of ptsv +#define LAPACK_SPTSV FORTRAN_ID2( sptsv, SPTSV ) +#define LAPACK_DPTSV FORTRAN_ID2( dptsv, DPTSV ) +#define LAPACK_CPTSV FORTRAN_ID2( cptsv, CPTSV ) +#define LAPACK_ZPTSV FORTRAN_ID2( zptsv, ZPTSV ) + +// Value-type variants of ptsvx +#define LAPACK_SPTSVX FORTRAN_ID2( sptsvx, SPTSVX ) +#define LAPACK_DPTSVX FORTRAN_ID2( dptsvx, DPTSVX ) +#define LAPACK_CPTSVX FORTRAN_ID2( cptsvx, CPTSVX ) +#define LAPACK_ZPTSVX FORTRAN_ID2( zptsvx, ZPTSVX ) + +// Value-type variants of spsv +#define LAPACK_SSPSV FORTRAN_ID2( sspsv, SSPSV ) +#define LAPACK_DSPSV FORTRAN_ID2( dspsv, DSPSV ) +#define LAPACK_CSPSV FORTRAN_ID2( cspsv, CSPSV ) +#define LAPACK_ZSPSV FORTRAN_ID2( zspsv, ZSPSV ) + +// Value-type variants of spsvx +#define LAPACK_SSPSVX FORTRAN_ID2( sspsvx, SSPSVX ) +#define LAPACK_DSPSVX FORTRAN_ID2( dspsvx, DSPSVX ) +#define LAPACK_CSPSVX FORTRAN_ID2( cspsvx, CSPSVX ) +#define LAPACK_ZSPSVX FORTRAN_ID2( zspsvx, ZSPSVX ) + +// Value-type variants of sysv +#define LAPACK_SSYSV FORTRAN_ID2( ssysv, SSYSV ) +#define LAPACK_DSYSV FORTRAN_ID2( dsysv, DSYSV ) +#define LAPACK_CSYSV FORTRAN_ID2( csysv, CSYSV ) +#define LAPACK_ZSYSV FORTRAN_ID2( zsysv, ZSYSV ) + +// Value-type variants of sysvx +#define LAPACK_SSYSVX FORTRAN_ID2( ssysvx, SSYSVX ) +#define LAPACK_DSYSVX FORTRAN_ID2( dsysvx, DSYSVX ) +#define LAPACK_CSYSVX FORTRAN_ID2( csysvx, CSYSVX ) +#define LAPACK_ZSYSVX FORTRAN_ID2( zsysvx, ZSYSVX ) + +// Value-type variants of gees +#define LAPACK_SGEES FORTRAN_ID2( sgees, SGEES ) +#define LAPACK_DGEES FORTRAN_ID2( dgees, DGEES ) +#define LAPACK_CGEES FORTRAN_ID2( cgees, CGEES ) +#define LAPACK_ZGEES FORTRAN_ID2( zgees, ZGEES ) + +// Value-type variants of geesx +#define LAPACK_SGEESX FORTRAN_ID2( sgeesx, SGEESX ) +#define LAPACK_DGEESX FORTRAN_ID2( dgeesx, DGEESX ) +#define LAPACK_CGEESX FORTRAN_ID2( cgeesx, CGEESX ) +#define LAPACK_ZGEESX FORTRAN_ID2( zgeesx, ZGEESX ) + +// Value-type variants of geev +#define LAPACK_SGEEV FORTRAN_ID2( sgeev, SGEEV ) +#define LAPACK_DGEEV FORTRAN_ID2( dgeev, DGEEV ) +#define LAPACK_CGEEV FORTRAN_ID2( cgeev, CGEEV ) +#define LAPACK_ZGEEV FORTRAN_ID2( zgeev, ZGEEV ) + +// Value-type variants of geevx +#define LAPACK_SGEEVX FORTRAN_ID2( sgeevx, SGEEVX ) +#define LAPACK_DGEEVX FORTRAN_ID2( dgeevx, DGEEVX ) +#define LAPACK_CGEEVX FORTRAN_ID2( cgeevx, CGEEVX ) +#define LAPACK_ZGEEVX FORTRAN_ID2( zgeevx, ZGEEVX ) + +// Value-type variants of gesdd +#define LAPACK_SGESDD FORTRAN_ID2( sgesdd, SGESDD ) +#define LAPACK_DGESDD FORTRAN_ID2( dgesdd, DGESDD ) +#define LAPACK_CGESDD FORTRAN_ID2( cgesdd, CGESDD ) +#define LAPACK_ZGESDD FORTRAN_ID2( zgesdd, ZGESDD ) + +// Value-type variants of gesvd +#define LAPACK_SGESVD FORTRAN_ID2( sgesvd, SGESVD ) +#define LAPACK_DGESVD FORTRAN_ID2( dgesvd, DGESVD ) +#define LAPACK_CGESVD FORTRAN_ID2( cgesvd, CGESVD ) +#define LAPACK_ZGESVD FORTRAN_ID2( zgesvd, ZGESVD ) + +// Value-type variants of hbev +#define LAPACK_CHBEV FORTRAN_ID2( chbev, CHBEV ) +#define LAPACK_ZHBEV FORTRAN_ID2( zhbev, ZHBEV ) + +// Value-type variants of hbevd +#define LAPACK_CHBEVD FORTRAN_ID2( chbevd, CHBEVD ) +#define LAPACK_ZHBEVD FORTRAN_ID2( zhbevd, ZHBEVD ) + +// Value-type variants of hbevx +#define LAPACK_CHBEVX FORTRAN_ID2( chbevx, CHBEVX ) +#define LAPACK_ZHBEVX FORTRAN_ID2( zhbevx, ZHBEVX ) + +// Value-type variants of heev +#define LAPACK_CHEEV FORTRAN_ID2( cheev, CHEEV ) +#define LAPACK_ZHEEV FORTRAN_ID2( zheev, ZHEEV ) + +// Value-type variants of heevd +#define LAPACK_CHEEVD FORTRAN_ID2( cheevd, CHEEVD ) +#define LAPACK_ZHEEVD FORTRAN_ID2( zheevd, ZHEEVD ) + +// Value-type variants of heevr +#define LAPACK_CHEEVR FORTRAN_ID2( cheevr, CHEEVR ) +#define LAPACK_ZHEEVR FORTRAN_ID2( zheevr, ZHEEVR ) + +// Value-type variants of heevx +#define LAPACK_CHEEVX FORTRAN_ID2( cheevx, CHEEVX ) +#define LAPACK_ZHEEVX FORTRAN_ID2( zheevx, ZHEEVX ) + +// Value-type variants of hpev +#define LAPACK_CHPEV FORTRAN_ID2( chpev, CHPEV ) +#define LAPACK_ZHPEV FORTRAN_ID2( zhpev, ZHPEV ) + +// Value-type variants of hpevd +#define LAPACK_CHPEVD FORTRAN_ID2( chpevd, CHPEVD ) +#define LAPACK_ZHPEVD FORTRAN_ID2( zhpevd, ZHPEVD ) + +// Value-type variants of hpevx +#define LAPACK_CHPEVX FORTRAN_ID2( chpevx, CHPEVX ) +#define LAPACK_ZHPEVX FORTRAN_ID2( zhpevx, ZHPEVX ) + +// Value-type variants of sbev +#define LAPACK_SSBEV FORTRAN_ID2( ssbev, SSBEV ) +#define LAPACK_DSBEV FORTRAN_ID2( dsbev, DSBEV ) + +// Value-type variants of sbevd +#define LAPACK_SSBEVD FORTRAN_ID2( ssbevd, SSBEVD ) +#define LAPACK_DSBEVD FORTRAN_ID2( dsbevd, DSBEVD ) + +// Value-type variants of sbevx +#define LAPACK_SSBEVX FORTRAN_ID2( ssbevx, SSBEVX ) +#define LAPACK_DSBEVX FORTRAN_ID2( dsbevx, DSBEVX ) + +// Value-type variants of spev +#define LAPACK_SSPEV FORTRAN_ID2( sspev, SSPEV ) +#define LAPACK_DSPEV FORTRAN_ID2( dspev, DSPEV ) + +// Value-type variants of spevd +#define LAPACK_SSPEVD FORTRAN_ID2( sspevd, SSPEVD ) +#define LAPACK_DSPEVD FORTRAN_ID2( dspevd, DSPEVD ) + +// Value-type variants of spevx +#define LAPACK_SSPEVX FORTRAN_ID2( sspevx, SSPEVX ) +#define LAPACK_DSPEVX FORTRAN_ID2( dspevx, DSPEVX ) + +// Value-type variants of stev +#define LAPACK_SSTEV FORTRAN_ID2( sstev, SSTEV ) +#define LAPACK_DSTEV FORTRAN_ID2( dstev, DSTEV ) + +// Value-type variants of stevd +#define LAPACK_SSTEVD FORTRAN_ID2( sstevd, SSTEVD ) +#define LAPACK_DSTEVD FORTRAN_ID2( dstevd, DSTEVD ) + +// Value-type variants of stevr +#define LAPACK_SSTEVR FORTRAN_ID2( sstevr, SSTEVR ) +#define LAPACK_DSTEVR FORTRAN_ID2( dstevr, DSTEVR ) + +// Value-type variants of stevx +#define LAPACK_SSTEVX FORTRAN_ID2( sstevx, SSTEVX ) +#define LAPACK_DSTEVX FORTRAN_ID2( dstevx, DSTEVX ) + +// Value-type variants of syev +#define LAPACK_SSYEV FORTRAN_ID2( ssyev, SSYEV ) +#define LAPACK_DSYEV FORTRAN_ID2( dsyev, DSYEV ) + +// Value-type variants of syevd +#define LAPACK_SSYEVD FORTRAN_ID2( ssyevd, SSYEVD ) +#define LAPACK_DSYEVD FORTRAN_ID2( dsyevd, DSYEVD ) + +// Value-type variants of syevr +#define LAPACK_SSYEVR FORTRAN_ID2( ssyevr, SSYEVR ) +#define LAPACK_DSYEVR FORTRAN_ID2( dsyevr, DSYEVR ) + +// Value-type variants of syevx +#define LAPACK_SSYEVX FORTRAN_ID2( ssyevx, SSYEVX ) +#define LAPACK_DSYEVX FORTRAN_ID2( dsyevx, DSYEVX ) + +// Value-type variants of gels +#define LAPACK_SGELS FORTRAN_ID2( sgels, SGELS ) +#define LAPACK_DGELS FORTRAN_ID2( dgels, DGELS ) +#define LAPACK_CGELS FORTRAN_ID2( cgels, CGELS ) +#define LAPACK_ZGELS FORTRAN_ID2( zgels, ZGELS ) + +// Value-type variants of gelsd +#define LAPACK_SGELSD FORTRAN_ID2( sgelsd, SGELSD ) +#define LAPACK_DGELSD FORTRAN_ID2( dgelsd, DGELSD ) +#define LAPACK_CGELSD FORTRAN_ID2( cgelsd, CGELSD ) +#define LAPACK_ZGELSD FORTRAN_ID2( zgelsd, ZGELSD ) + +// Value-type variants of gelss +#define LAPACK_SGELSS FORTRAN_ID2( sgelss, SGELSS ) +#define LAPACK_DGELSS FORTRAN_ID2( dgelss, DGELSS ) +#define LAPACK_CGELSS FORTRAN_ID2( cgelss, CGELSS ) +#define LAPACK_ZGELSS FORTRAN_ID2( zgelss, ZGELSS ) + +// Value-type variants of gelsy +#define LAPACK_SGELSY FORTRAN_ID2( sgelsy, SGELSY ) +#define LAPACK_DGELSY FORTRAN_ID2( dgelsy, DGELSY ) +#define LAPACK_CGELSY FORTRAN_ID2( cgelsy, CGELSY ) +#define LAPACK_ZGELSY FORTRAN_ID2( zgelsy, ZGELSY ) + +// +// LAPACK auxiliary routines +// + +// Value-type variants of larf +#define LAPACK_SLARF FORTRAN_ID2( slarf, SLARF ) +#define LAPACK_DLARF FORTRAN_ID2( dlarf, DLARF ) +#define LAPACK_CLARF FORTRAN_ID2( clarf, CLARF ) +#define LAPACK_ZLARF FORTRAN_ID2( zlarf, ZLARF ) + +// Value-type variants of larfb +#define LAPACK_SLARFB FORTRAN_ID2( slarfb, SLARFB ) +#define LAPACK_DLARFB FORTRAN_ID2( dlarfb, DLARFB ) +#define LAPACK_CLARFB FORTRAN_ID2( clarfb, CLARFB ) +#define LAPACK_ZLARFB FORTRAN_ID2( zlarfb, ZLARFB ) + +// Value-type variants of larfg +#define LAPACK_SLARFG FORTRAN_ID2( slarfg, SLARFG ) +#define LAPACK_DLARFG FORTRAN_ID2( dlarfg, DLARFG ) +#define LAPACK_CLARFG FORTRAN_ID2( clarfg, CLARFG ) +#define LAPACK_ZLARFG FORTRAN_ID2( zlarfg, ZLARFG ) + +// Value-type variants of larft +#define LAPACK_SLARFT FORTRAN_ID2( slarft, SLARFT ) +#define LAPACK_DLARFT FORTRAN_ID2( dlarft, DLARFT ) +#define LAPACK_CLARFT FORTRAN_ID2( clarft, CLARFT ) +#define LAPACK_ZLARFT FORTRAN_ID2( zlarft, ZLARFT ) + +// Value-type variants of larfx +#define LAPACK_SLARFX FORTRAN_ID2( slarfx, SLARFX ) +#define LAPACK_DLARFX FORTRAN_ID2( dlarfx, DLARFX ) +#define LAPACK_CLARFX FORTRAN_ID2( clarfx, CLARFX ) +#define LAPACK_ZLARFX FORTRAN_ID2( zlarfx, ZLARFX ) + +// Value-type variants of largv +#define LAPACK_SLARGV FORTRAN_ID2( slargv, SLARGV ) +#define LAPACK_DLARGV FORTRAN_ID2( dlargv, DLARGV ) +#define LAPACK_CLARGV FORTRAN_ID2( clargv, CLARGV ) +#define LAPACK_ZLARGV FORTRAN_ID2( zlargv, ZLARGV ) + +// Value-type variants of larnv +#define LAPACK_SLARNV FORTRAN_ID2( slarnv, SLARNV ) +#define LAPACK_DLARNV FORTRAN_ID2( dlarnv, DLARNV ) +#define LAPACK_CLARNV FORTRAN_ID2( clarnv, CLARNV ) +#define LAPACK_ZLARNV FORTRAN_ID2( zlarnv, ZLARNV ) + +// Value-type variants of larrb +#define LAPACK_SLARRB FORTRAN_ID2( slarrb, SLARRB ) +#define LAPACK_DLARRB FORTRAN_ID2( dlarrb, DLARRB ) + +// Value-type variants of larre +#define LAPACK_SLARRE FORTRAN_ID2( slarre, SLARRE ) +#define LAPACK_DLARRE FORTRAN_ID2( dlarre, DLARRE ) + +// Value-type variants of langb +#define LAPACK_SLANGB FORTRAN_ID2( slangb, SLANGB ) +#define LAPACK_DLANGB FORTRAN_ID2( dlangb, DLANGB ) +#define LAPACK_CLANGB FORTRAN_ID2( clangb, CLANGB ) +#define LAPACK_ZLANGB FORTRAN_ID2( zlangb, ZLANGB ) + +// Value-type variants of lange +#define LAPACK_SLANGE FORTRAN_ID2( slange, SLANGE ) +#define LAPACK_DLANGE FORTRAN_ID2( dlange, DLANGE ) +#define LAPACK_CLANGE FORTRAN_ID2( clange, CLANGE ) +#define LAPACK_ZLANGE FORTRAN_ID2( zlange, ZLANGE ) + +// Value-type variants of lanhb +#define LAPACK_CLANHB FORTRAN_ID2( clanhb, CLANHB ) +#define LAPACK_ZLANHB FORTRAN_ID2( zlanhb, ZLANHB ) + +// Value-type variants of lanhe +#define LAPACK_CLANHE FORTRAN_ID2( clanhe, CLANHE ) +#define LAPACK_ZLANHE FORTRAN_ID2( zlanhe, ZLANHE ) + +// Value-type variants of lanhp +#define LAPACK_CLANHP FORTRAN_ID2( clanhp, CLANHP ) +#define LAPACK_ZLANHP FORTRAN_ID2( zlanhp, ZLANHP ) + +// Value-type variants of lanhs +#define LAPACK_SLANHS FORTRAN_ID2( slanhs, SLANHS ) +#define LAPACK_DLANHS FORTRAN_ID2( dlanhs, DLANHS ) +#define LAPACK_CLANHS FORTRAN_ID2( clanhs, CLANHS ) +#define LAPACK_ZLANHS FORTRAN_ID2( zlanhs, ZLANHS ) + +// Value-type variants of lansb +#define LAPACK_SLANSB FORTRAN_ID2( slansb, SLANSB ) +#define LAPACK_DLANSB FORTRAN_ID2( dlansb, DLANSB ) +#define LAPACK_CLANSB FORTRAN_ID2( clansb, CLANSB ) +#define LAPACK_ZLANSB FORTRAN_ID2( zlansb, ZLANSB ) + +// Value-type variants of lansp +#define LAPACK_SLANSP FORTRAN_ID2( slansp, SLANSP ) +#define LAPACK_DLANSP FORTRAN_ID2( dlansp, DLANSP ) +#define LAPACK_CLANSP FORTRAN_ID2( clansp, CLANSP ) +#define LAPACK_ZLANSP FORTRAN_ID2( zlansp, ZLANSP ) + +// Value-type variants of lansy +#define LAPACK_SLANSY FORTRAN_ID2( slansy, SLANSY ) +#define LAPACK_DLANSY FORTRAN_ID2( dlansy, DLANSY ) +#define LAPACK_CLANSY FORTRAN_ID2( clansy, CLANSY ) +#define LAPACK_ZLANSY FORTRAN_ID2( zlansy, ZLANSY ) + +// Value-type variants of lantb +#define LAPACK_SLANTB FORTRAN_ID2( slantb, SLANTB ) +#define LAPACK_DLANTB FORTRAN_ID2( dlantb, DLANTB ) +#define LAPACK_CLANTB FORTRAN_ID2( clantb, CLANTB ) +#define LAPACK_ZLANTB FORTRAN_ID2( zlantb, ZLANTB ) + +// Value-type variants of lantp +#define LAPACK_SLANTP FORTRAN_ID2( slantp, SLANTP ) +#define LAPACK_DLANTP FORTRAN_ID2( dlantp, DLANTP ) +#define LAPACK_CLANTP FORTRAN_ID2( clantp, CLANTP ) +#define LAPACK_ZLANTP FORTRAN_ID2( zlantp, ZLANTP ) + +// Value-type variants of lantr +#define LAPACK_SLANTR FORTRAN_ID2( slantr, SLANTR ) +#define LAPACK_DLANTR FORTRAN_ID2( dlantr, DLANTR ) +#define LAPACK_CLANTR FORTRAN_ID2( clantr, CLANTR ) +#define LAPACK_ZLANTR FORTRAN_ID2( zlantr, ZLANTR ) + +// Value-type variants of labrd +#define LAPACK_SLABRD FORTRAN_ID2( slabrd, SLABRD ) +#define LAPACK_DLABRD FORTRAN_ID2( dlabrd, DLABRD ) +#define LAPACK_CLABRD FORTRAN_ID2( clabrd, CLABRD ) +#define LAPACK_ZLABRD FORTRAN_ID2( zlabrd, ZLABRD ) + +// Value-type variants of lacgv +#define LAPACK_CLACGV FORTRAN_ID2( clacgv, CLACGV ) +#define LAPACK_ZLACGV FORTRAN_ID2( zlacgv, ZLACGV ) + +// Value-type variants of lacon +#define LAPACK_SLACON FORTRAN_ID2( slacon, SLACON ) +#define LAPACK_DLACON FORTRAN_ID2( dlacon, DLACON ) +#define LAPACK_CLACON FORTRAN_ID2( clacon, CLACON ) +#define LAPACK_ZLACON FORTRAN_ID2( zlacon, ZLACON ) + +// Value-type variants of laebz +#define LAPACK_SLAEBZ FORTRAN_ID2( slaebz, SLAEBZ ) +#define LAPACK_DLAEBZ FORTRAN_ID2( dlaebz, DLAEBZ ) + +// Value-type variants of lalsd +#define LAPACK_SLALSD FORTRAN_ID2( slalsd, SLALSD ) +#define LAPACK_DLALSD FORTRAN_ID2( dlalsd, DLALSD ) +#define LAPACK_CLALSD FORTRAN_ID2( clalsd, CLALSD ) +#define LAPACK_ZLALSD FORTRAN_ID2( zlalsd, ZLALSD ) + +// Value-type variants of largv +#define LAPACK_SLARGV FORTRAN_ID2( slargv, SLARGV ) +#define LAPACK_DLARGV FORTRAN_ID2( dlargv, DLARGV ) +#define LAPACK_CLARGV FORTRAN_ID2( clargv, CLARGV ) +#define LAPACK_ZLARGV FORTRAN_ID2( zlargv, ZLARGV ) + +// Value-type variants of larz +#define LAPACK_SLARZ FORTRAN_ID2( slarz, SLARZ ) +#define LAPACK_DLARZ FORTRAN_ID2( dlarz, DLARZ ) +#define LAPACK_CLARZ FORTRAN_ID2( clarz, CLARZ ) +#define LAPACK_ZLARZ FORTRAN_ID2( zlarz, ZLARZ ) + +// Value-type variants of latrd +#define LAPACK_SLATRD FORTRAN_ID2( slatrd, SLATRD ) +#define LAPACK_DLATRD FORTRAN_ID2( dlatrd, DLATRD ) +#define LAPACK_CLATRD FORTRAN_ID2( clatrd, CLATRD ) +#define LAPACK_ZLATRD FORTRAN_ID2( zlatrd, ZLATRD ) + +// Value-type variants of latrs +#define LAPACK_SLATRS FORTRAN_ID2( slatrs, SLATRS ) +#define LAPACK_DLATRS FORTRAN_ID2( dlatrs, DLATRS ) +#define LAPACK_CLATRS FORTRAN_ID2( clatrs, CLATRS ) +#define LAPACK_ZLATRS FORTRAN_ID2( zlatrs, ZLATRS ) + +// Value-type variants of latrz +#define LAPACK_SLATRZ FORTRAN_ID2( slatrz, SLATRZ ) +#define LAPACK_DLATRZ FORTRAN_ID2( dlatrz, DLATRZ ) +#define LAPACK_CLATRZ FORTRAN_ID2( clatrz, CLATRZ ) +#define LAPACK_ZLATRZ FORTRAN_ID2( zlatrz, ZLATRZ ) + +// +// LAPACK auxiliary routines +// + +#define LAPACK_ILAENV FORTRAN_ID2( ilaenv, ILAENV ) + +#endif + diff --git a/sdk/boost/numeric/bindings/lapack/detail/lapack_option.hpp b/sdk/boost/numeric/bindings/lapack/detail/lapack_option.hpp new file mode 100644 index 0000000..292b6ec --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/detail/lapack_option.hpp @@ -0,0 +1,32 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_LAPACK_OPTION_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DETAIL_LAPACK_OPTION_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { +namespace detail { + +template< typename Tag > +struct lapack_option: bindings::blas::detail::blas_option< Tag > {}; + +template<> +struct lapack_option< tag::both >: mpl::char_< 'B' > {}; + +} // namespace detail +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver.hpp b/sdk/boost/numeric/bindings/lapack/driver.hpp new file mode 100644 index 0000000..ef08398 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver.hpp @@ -0,0 +1,103 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gbsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/gbsv.hpp new file mode 100644 index 0000000..518e3bf --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gbsv.hpp @@ -0,0 +1,183 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GBSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GBSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gbsv( const fortran_int_t n, const fortran_int_t kl, + const fortran_int_t ku, const fortran_int_t nrhs, float* ab, + const fortran_int_t ldab, fortran_int_t* ipiv, float* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gbsv( const fortran_int_t n, const fortran_int_t kl, + const fortran_int_t ku, const fortran_int_t nrhs, double* ab, + const fortran_int_t ldab, fortran_int_t* ipiv, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbsv( const fortran_int_t n, const fortran_int_t kl, + const fortran_int_t ku, const fortran_int_t nrhs, + std::complex* ab, const fortran_int_t ldab, + fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gbsv( const fortran_int_t n, const fortran_int_t kl, + const fortran_int_t ku, const fortran_int_t nrhs, + std::complex* ab, const fortran_int_t ldab, + fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZGBSV( &n, &kl, &ku, &nrhs, ab, &ldab, ipiv, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbsv. +// +template< typename Value > +struct gbsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixAB& ab, VectorIPIV& ipiv, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower(ab) >= 0 ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + 2*bindings::bandwidth_lower(ab)+(bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab))+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)) >= 0 ); + return detail::gbsv( bindings::size_column(ab), + bindings::bandwidth_lower(ab), (bindings::bandwidth_upper(ab)- + bindings::bandwidth_lower(ab)), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbsv. Its overload differs for +// +template< typename MatrixAB, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t gbsv( MatrixAB& ab, VectorIPIV& ipiv, MatrixB& b ) { + return gbsv_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gbsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/gbsvx.hpp new file mode 100644 index 0000000..c1a7544 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gbsvx.hpp @@ -0,0 +1,547 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GBSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GBSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gbsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, float* ab, const fortran_int_t ldab, + float* afb, const fortran_int_t ldafb, fortran_int_t* ipiv, + char& equed, float* r, float* c, float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float& rcond, float* ferr, + float* berr, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGBSVX( &fact, &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, + ab, &ldab, afb, &ldafb, ipiv, &equed, r, c, b, &ldb, x, &ldx, + &rcond, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, double* ab, const fortran_int_t ldab, + double* afb, const fortran_int_t ldafb, fortran_int_t* ipiv, + char& equed, double* r, double* c, double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double& rcond, double* ferr, + double* berr, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGBSVX( &fact, &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, + ab, &ldab, afb, &ldafb, ipiv, &equed, r, c, b, &ldb, x, &ldx, + &rcond, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, std::complex* ab, + const fortran_int_t ldab, std::complex* afb, + const fortran_int_t ldafb, fortran_int_t* ipiv, char& equed, float* r, + float* c, std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGBSVX( &fact, &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, + ab, &ldab, afb, &ldafb, ipiv, &equed, r, c, b, &ldb, x, &ldx, + &rcond, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gbsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t kl, const fortran_int_t ku, + const fortran_int_t nrhs, std::complex* ab, + const fortran_int_t ldab, std::complex* afb, + const fortran_int_t ldafb, fortran_int_t* ipiv, char& equed, + double* r, double* c, std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGBSVX( &fact, &lapack_option< Trans >::value, &n, &kl, &ku, &nrhs, + ab, &ldab, afb, &ldafb, ipiv, &equed, r, c, b, &ldb, x, &ldx, + &rcond, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gbsvx. +// +template< typename Value, typename Enable = void > +struct gbsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gbsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r, + VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= + 2*bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())) >= 0 ); + BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' || + equed == 'B' ); + BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' ); + return detail::gbsvx( fact, trans(), bindings::size_column_op(ab, + trans()), bindings::bandwidth_lower_op(ab, trans()), + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())), + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(afb), + bindings::stride_major(afb), bindings::begin_value(ipiv), + equed, bindings::begin_value(r), bindings::begin_value(c), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r, + VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(ab, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(ab, trans()) ) ); + return invoke( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr, + berr, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r, + VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + return invoke( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr, + berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gbsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r, + VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth_lower_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(ab, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(ab, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= + bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= + 2*bindings::bandwidth_lower_op(ab, trans())+ + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans()))+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(ab, trans())) ); + BOOST_ASSERT( (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())) >= 0 ); + BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' || + equed == 'B' ); + BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' ); + return detail::gbsvx( fact, trans(), bindings::size_column_op(ab, + trans()), bindings::bandwidth_lower_op(ab, trans()), + (bindings::bandwidth_upper_op(ab, trans())- + bindings::bandwidth_lower_op(ab, trans())), + bindings::size_column(b), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(afb), + bindings::stride_major(afb), bindings::begin_value(ipiv), + equed, bindings::begin_value(r), bindings::begin_value(c), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r, + VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(ab, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(ab, trans()) ) ); + return invoke( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr, + berr, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, VectorIPIV& ipiv, char& equed, VectorR& r, + VectorC& c, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAFB >::type order; + typedef typename result_of::trans_tag< MatrixAB, order >::type trans; + return invoke( fact, ab, afb, ipiv, equed, r, c, b, x, rcond, ferr, + berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gbsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gbsvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gbsvx( const char fact, MatrixAB& ab, MatrixAFB& afb, VectorIPIV& ipiv, + char& equed, VectorR& r, VectorC& c, MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return gbsvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( fact, ab, afb, ipiv, equed, r, c, b, + x, rcond, ferr, berr, work ); +} + +// +// Overloaded function for gbsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixAFB, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +gbsvx( const char fact, MatrixAB& ab, MatrixAFB& afb, VectorIPIV& ipiv, + char& equed, VectorR& r, VectorC& c, MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) { + return gbsvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( fact, ab, afb, ipiv, equed, r, c, b, + x, rcond, ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gees.hpp b/sdk/boost/numeric/bindings/lapack/driver/gees.hpp new file mode 100644 index 0000000..42c765a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gees.hpp @@ -0,0 +1,520 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEES_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEES_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gees is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gees( const char jobvs, const char sort, + external_fp select, const fortran_int_t n, float* a, + const fortran_int_t lda, fortran_int_t& sdim, float* wr, float* wi, + float* vs, const fortran_int_t ldvs, float* work, + const fortran_int_t lwork, fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_SGEES( &jobvs, &sort, select, &n, a, &lda, &sdim, wr, wi, vs, + &ldvs, work, &lwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gees( const char jobvs, const char sort, + external_fp select, const fortran_int_t n, double* a, + const fortran_int_t lda, fortran_int_t& sdim, double* wr, double* wi, + double* vs, const fortran_int_t ldvs, double* work, + const fortran_int_t lwork, fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_DGEES( &jobvs, &sort, select, &n, a, &lda, &sdim, wr, wi, vs, + &ldvs, work, &lwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gees( const char jobvs, const char sort, + external_fp select, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, fortran_int_t& sdim, std::complex* w, + std::complex* vs, const fortran_int_t ldvs, + std::complex* work, const fortran_int_t lwork, float* rwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_CGEES( &jobvs, &sort, select, &n, a, &lda, &sdim, w, vs, &ldvs, + work, &lwork, rwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gees( const char jobvs, const char sort, + external_fp select, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, fortran_int_t& sdim, std::complex* w, + std::complex* vs, const fortran_int_t ldvs, + std::complex* work, const fortran_int_t lwork, double* rwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_ZGEES( &jobvs, &sort, select, &n, a, &lda, &sdim, w, vs, &ldvs, + work, &lwork, rwork, bwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gees. +// +template< typename Value, typename Enable = void > +struct gees_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gees_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS, typename WORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, MatrixA& a, fortran_int_t& sdim, + VectorWR& wr, VectorWI& wi, MatrixVS& vs, detail::workspace2< + WORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVS >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) ); + BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vs) == 1 || + bindings::stride_minor(vs) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::gees( jobvs, sort, select, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), sdim, + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(vs), bindings::stride_major(vs), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, MatrixA& a, fortran_int_t& sdim, + VectorWR& wr, VectorWI& wi, MatrixVS& vs, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvs, sort, select, a, sdim, wr, wi, vs, + workspace( tmp_work, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, MatrixA& a, fortran_int_t& sdim, + VectorWR& wr, VectorWI& wi, MatrixVS& vs, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::gees( jobvs, sort, select, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), sdim, + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(vs), bindings::stride_major(vs), + &opt_size_work, -1, bindings::begin_value(tmp_bwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvs, sort, select, a, sdim, wr, wi, vs, + workspace( tmp_work, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 3*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gees_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixVS, + typename WORK, typename RWORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, MatrixA& a, fortran_int_t& sdim, + VectorW& w, MatrixVS& vs, detail::workspace3< WORK, RWORK, + BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVS >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vs) == 1 || + bindings::stride_minor(vs) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::gees( jobvs, sort, select, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), sdim, + bindings::begin_value(w), bindings::begin_value(vs), + bindings::stride_major(vs), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, MatrixA& a, fortran_int_t& sdim, + VectorW& w, MatrixVS& vs, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvs, sort, select, a, sdim, w, vs, + workspace( tmp_work, tmp_rwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, MatrixA& a, fortran_int_t& sdim, + VectorW& w, MatrixVS& vs, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::gees( jobvs, sort, select, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), sdim, + bindings::begin_value(w), bindings::begin_value(vs), + bindings::stride_major(vs), &opt_size_work, -1, + bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvs, sort, select, a, sdim, w, vs, + workspace( tmp_work, tmp_rwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gees_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gees. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gees( const char jobvs, const char sort, external_fp select, MatrixA& a, + fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs, + Workspace work ) { + return gees_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, a, sdim, wr, wi, + vs, work ); +} + +// +// Overloaded function for gees. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS > +inline typename boost::disable_if< detail::is_workspace< MatrixVS >, + std::ptrdiff_t >::type +gees( const char jobvs, const char sort, external_fp select, MatrixA& a, + fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs ) { + return gees_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, a, sdim, wr, wi, + vs, optimal_workspace() ); +} + +// +// Overloaded function for gees. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixVS, + typename Workspace > +inline typename boost::enable_if< mpl::and_< is_complex< + typename bindings::value_type< MatrixA >::type >, + detail::is_workspace< Workspace > >, + std::ptrdiff_t >::type +gees( const char jobvs, const char sort, external_fp select, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs, Workspace work ) { + return gees_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, a, sdim, w, vs, + work ); +} + +// +// Overloaded function for gees. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixVS > +inline typename boost::disable_if< mpl::or_< is_real< + typename bindings::value_type< MatrixA >::type >, + detail::is_workspace< MatrixVS > >, + std::ptrdiff_t >::type +gees( const char jobvs, const char sort, external_fp select, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs ) { + return gees_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, a, sdim, w, vs, + optimal_workspace() ); +} + +// +// Overloaded function for gees. Its overload differs for +// * VectorW +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixVS, + typename Workspace > +inline typename boost::enable_if< mpl::and_< is_real< + typename bindings::value_type< MatrixA >::type >, + detail::is_workspace< Workspace > >, + std::ptrdiff_t >::type +gees( const char jobvs, const char sort, external_fp select, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs, Workspace work ) { + std::ptrdiff_t info = gees_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, a, sdim, + bindings::detail::real_part_view(w), bindings::detail::imag_part_view(w), + vs, work ); + bindings::detail::interlace(w); + return info; +} + +// +// Overloaded function for gees. Its overload differs for +// * VectorW +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixVS > +inline typename boost::disable_if< mpl::or_< is_complex< + typename bindings::value_type< MatrixA >::type >, + detail::is_workspace< MatrixVS > >, + std::ptrdiff_t >::type +gees( const char jobvs, const char sort, external_fp select, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs ) { + std::ptrdiff_t info = gees_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, a, sdim, + bindings::detail::real_part_view(w), bindings::detail::imag_part_view(w), + vs, optimal_workspace() ); + bindings::detail::interlace(w); + return info; +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/geesx.hpp b/sdk/boost/numeric/bindings/lapack/driver/geesx.hpp new file mode 100644 index 0000000..6486213 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/geesx.hpp @@ -0,0 +1,537 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEESX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEESX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geesx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geesx( const char jobvs, const char sort, + external_fp select, const char sense, const fortran_int_t n, float* a, + const fortran_int_t lda, fortran_int_t& sdim, float* wr, float* wi, + float* vs, const fortran_int_t ldvs, float& rconde, float& rcondv, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork, fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_SGEESX( &jobvs, &sort, select, &sense, &n, a, &lda, &sdim, wr, wi, + vs, &ldvs, &rconde, &rcondv, work, &lwork, iwork, &liwork, bwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geesx( const char jobvs, const char sort, + external_fp select, const char sense, const fortran_int_t n, + double* a, const fortran_int_t lda, fortran_int_t& sdim, double* wr, + double* wi, double* vs, const fortran_int_t ldvs, double& rconde, + double& rcondv, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_DGEESX( &jobvs, &sort, select, &sense, &n, a, &lda, &sdim, wr, wi, + vs, &ldvs, &rconde, &rcondv, work, &lwork, iwork, &liwork, bwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geesx( const char jobvs, const char sort, + external_fp select, const char sense, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t& sdim, + std::complex* w, std::complex* vs, + const fortran_int_t ldvs, float& rconde, float& rcondv, + std::complex* work, const fortran_int_t lwork, float* rwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_CGEESX( &jobvs, &sort, select, &sense, &n, a, &lda, &sdim, w, vs, + &ldvs, &rconde, &rcondv, work, &lwork, rwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geesx( const char jobvs, const char sort, + external_fp select, const char sense, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, fortran_int_t& sdim, + std::complex* w, std::complex* vs, + const fortran_int_t ldvs, double& rconde, double& rcondv, + std::complex* work, const fortran_int_t lwork, double* rwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_ZGEESX( &jobvs, &sort, select, &sense, &n, a, &lda, &sdim, w, vs, + &ldvs, &rconde, &rcondv, work, &lwork, rwork, bwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geesx. +// +template< typename Value, typename Enable = void > +struct geesx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geesx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS, typename WORK, typename IWORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, const char sense, MatrixA& a, + fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs, + real_type& rconde, real_type& rcondv, detail::workspace3< WORK, + IWORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVS >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) ); + BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vs) == 1 || + bindings::stride_minor(vs) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::geesx( jobvs, sort, select, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), sdim, bindings::begin_value(wr), + bindings::begin_value(wi), bindings::begin_value(vs), + bindings::stride_major(vs), rconde, rcondv, + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, const char sense, MatrixA& a, + fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs, + real_type& rconde, real_type& rcondv, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvs, sort, select, sense, a, sdim, wr, wi, vs, + rconde, rcondv, workspace( tmp_work, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, const char sense, MatrixA& a, + fortran_int_t& sdim, VectorWR& wr, VectorWI& wi, MatrixVS& vs, + real_type& rconde, real_type& rcondv, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::geesx( jobvs, sort, select, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), sdim, bindings::begin_value(wr), + bindings::begin_value(wi), bindings::begin_value(vs), + bindings::stride_major(vs), rconde, rcondv, &opt_size_work, + -1, &opt_size_iwork, -1, bindings::begin_value(tmp_bwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobvs, sort, select, sense, a, sdim, wr, wi, vs, + rconde, rcondv, workspace( tmp_work, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char sense ) { + if ( sense == 'N' ) + return std::max< std::ptrdiff_t >( 1, 3*n ); + else + return std::max< std::ptrdiff_t >( 1, n+n*n/2 ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char sense ) { + if ( sense == 'N' || sense == 'E' ) + return 1; + else + return std::max< std::ptrdiff_t >( 1, n*n/4 ); + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geesx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixVS, + typename WORK, typename RWORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, const char sense, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs, + real_type& rconde, real_type& rcondv, detail::workspace3< WORK, + RWORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVS >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVS >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vs) == 1 || + bindings::stride_minor(vs) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvs == 'N' || jobvs == 'V' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::geesx( jobvs, sort, select, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), sdim, bindings::begin_value(w), + bindings::begin_value(vs), bindings::stride_major(vs), rconde, + rcondv, bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, const char sense, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs, + real_type& rconde, real_type& rcondv, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), sense ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvs, sort, select, sense, a, sdim, w, vs, rconde, + rcondv, workspace( tmp_work, tmp_rwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixVS > + static std::ptrdiff_t invoke( const char jobvs, const char sort, + external_fp select, const char sense, MatrixA& a, + fortran_int_t& sdim, VectorW& w, MatrixVS& vs, + real_type& rconde, real_type& rcondv, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::geesx( jobvs, sort, select, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), sdim, bindings::begin_value(w), + bindings::begin_value(vs), bindings::stride_major(vs), rconde, + rcondv, &opt_size_work, -1, bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvs, sort, select, sense, a, sdim, w, vs, rconde, + rcondv, workspace( tmp_work, tmp_rwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char sense ) { + if ( sense == 'N' ) + return std::max< std::ptrdiff_t >( 1, 2*n ); + else + return std::max< std::ptrdiff_t >( 1, n*n/2 ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geesx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geesx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geesx( const char jobvs, const char sort, external_fp select, + const char sense, MatrixA& a, fortran_int_t& sdim, VectorWR& wr, + VectorWI& wi, MatrixVS& vs, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rconde, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcondv, Workspace work ) { + return geesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, sense, a, sdim, + wr, wi, vs, rconde, rcondv, work ); +} + +// +// Overloaded function for geesx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVS > +inline typename boost::disable_if< detail::is_workspace< MatrixVS >, + std::ptrdiff_t >::type +geesx( const char jobvs, const char sort, external_fp select, + const char sense, MatrixA& a, fortran_int_t& sdim, VectorWR& wr, + VectorWI& wi, MatrixVS& vs, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rconde, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcondv ) { + return geesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, sense, a, sdim, + wr, wi, vs, rconde, rcondv, optimal_workspace() ); +} + +// +// Overloaded function for geesx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixVS, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geesx( const char jobvs, const char sort, external_fp select, + const char sense, MatrixA& a, fortran_int_t& sdim, VectorW& w, + MatrixVS& vs, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rconde, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcondv, Workspace work ) { + return geesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, sense, a, sdim, w, + vs, rconde, rcondv, work ); +} + +// +// Overloaded function for geesx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixVS > +inline typename boost::disable_if< detail::is_workspace< MatrixVS >, + std::ptrdiff_t >::type +geesx( const char jobvs, const char sort, external_fp select, + const char sense, MatrixA& a, fortran_int_t& sdim, VectorW& w, + MatrixVS& vs, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rconde, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcondv ) { + return geesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvs, sort, select, sense, a, sdim, w, + vs, rconde, rcondv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/geev.hpp b/sdk/boost/numeric/bindings/lapack/driver/geev.hpp new file mode 100644 index 0000000..1754a06 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/geev.hpp @@ -0,0 +1,456 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geev( const char jobvl, const char jobvr, + const fortran_int_t n, float* a, const fortran_int_t lda, float* wr, + float* wi, float* vl, const fortran_int_t ldvl, float* vr, + const fortran_int_t ldvr, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEEV( &jobvl, &jobvr, &n, a, &lda, wr, wi, vl, &ldvl, vr, &ldvr, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geev( const char jobvl, const char jobvr, + const fortran_int_t n, double* a, const fortran_int_t lda, double* wr, + double* wi, double* vl, const fortran_int_t ldvl, double* vr, + const fortran_int_t ldvr, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEEV( &jobvl, &jobvr, &n, a, &lda, wr, wi, vl, &ldvl, vr, &ldvr, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geev( const char jobvl, const char jobvr, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* w, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + std::complex* work, const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGEEV( &jobvl, &jobvr, &n, a, &lda, w, vl, &ldvl, vr, &ldvr, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geev( const char jobvl, const char jobvr, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* w, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + std::complex* work, const fortran_int_t lwork, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGEEV( &jobvl, &jobvr, &n, a, &lda, w, vl, &ldvl, vr, &ldvr, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geev. +// +template< typename Value, typename Enable = void > +struct geev_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geev_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename WORK > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, VectorWR& wr, VectorWI& wi, MatrixVL& vl, + MatrixVR& vr, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobvl, jobvr, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + return detail::geev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, VectorWR& wr, VectorWI& wi, MatrixVL& vl, + MatrixVR& vr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( jobvl, + jobvr, bindings::size_column(a) ) ); + return invoke( jobvl, jobvr, a, wr, wi, vl, vr, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, VectorWR& wr, VectorWI& wi, MatrixVL& vl, + MatrixVR& vr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::geev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(wr), bindings::begin_value(wi), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvl, jobvr, a, wr, wi, vl, vr, + workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobvl, const char jobvr, + const std::ptrdiff_t n ) { + if ( jobvl == 'V' || jobvr == 'V' ) + return std::max< std::ptrdiff_t >( 1, 4*n ); + else + return std::max< std::ptrdiff_t >( 1, 3*n ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geev_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + return detail::geev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( jobvl, jobvr, a, w, vl, vr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::geev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), &opt_size_work, -1, + bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvl, jobvr, a, w, vl, vr, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geev( const char jobvl, const char jobvr, MatrixA& a, VectorWR& wr, + VectorWI& wi, MatrixVL& vl, MatrixVR& vr, Workspace work ) { + return geev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, wr, wi, vl, vr, work ); +} + +// +// Overloaded function for geev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +geev( const char jobvl, const char jobvr, MatrixA& a, VectorWR& wr, + VectorWI& wi, MatrixVL& vl, MatrixVR& vr ) { + return geev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, wr, wi, vl, vr, + optimal_workspace() ); +} + +// +// Overloaded function for geev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geev( const char jobvl, const char jobvr, MatrixA& a, VectorW& w, + MatrixVL& vl, MatrixVR& vr, Workspace work ) { + return geev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, w, vl, vr, work ); +} + +// +// Overloaded function for geev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +geev( const char jobvl, const char jobvr, MatrixA& a, VectorW& w, + MatrixVL& vl, MatrixVR& vr ) { + return geev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, w, vl, vr, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/geevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/geevx.hpp new file mode 100644 index 0000000..5eec32d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/geevx.hpp @@ -0,0 +1,597 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for geevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t geevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, float* a, + const fortran_int_t lda, float* wr, float* wi, float* vl, + const fortran_int_t ldvl, float* vr, const fortran_int_t ldvr, + fortran_int_t& ilo, fortran_int_t& ihi, float* scale, float& abnrm, + float* rconde, float* rcondv, float* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, wr, wi, vl, + &ldvl, vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t geevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, double* a, + const fortran_int_t lda, double* wr, double* wi, double* vl, + const fortran_int_t ldvl, double* vr, const fortran_int_t ldvr, + fortran_int_t& ilo, fortran_int_t& ihi, double* scale, double& abnrm, + double* rconde, double* rcondv, double* work, + const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, wr, wi, vl, + &ldvl, vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* w, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, fortran_int_t& ilo, fortran_int_t& ihi, + float* scale, float& abnrm, float* rconde, float* rcondv, + std::complex* work, const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, w, vl, &ldvl, + vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t geevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* w, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, fortran_int_t& ilo, fortran_int_t& ihi, + double* scale, double& abnrm, double* rconde, double* rcondv, + std::complex* work, const fortran_int_t lwork, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGEEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, w, vl, &ldvl, + vr, &ldvr, &ilo, &ihi, scale, &abnrm, rconde, rcondv, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to geevx. +// +template< typename Value, typename Enable = void > +struct geevx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct geevx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename VectorSCALE, + typename VectorRCONDE, typename VectorRCONDV, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, VectorWR& wr, + VectorWI& wi, MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace2< + WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorWI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorWI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) ); + BOOST_ASSERT( bindings::size(rconde) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(rcondv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(wi) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( sense, jobvl, jobvr, + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(wr) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' || + balanc == 'B' ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' || + jobvl == 'B' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' || jobvr == 'E' || + jobvr == 'B' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + return detail::geevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(wr), + bindings::begin_value(wi), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), ilo, ihi, + bindings::begin_value(scale), abnrm, + bindings::begin_value(rconde), bindings::begin_value(rcondv), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename VectorSCALE, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, VectorWR& wr, + VectorWI& wi, MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( sense, + jobvl, jobvr, bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( sense, bindings::size_column(a) ) ); + return invoke( balanc, jobvl, jobvr, sense, a, wr, wi, vl, vr, ilo, + ihi, scale, abnrm, rconde, rcondv, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename VectorSCALE, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, VectorWR& wr, + VectorWI& wi, MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( sense, bindings::size_column(a) ) ); + detail::geevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(wr), + bindings::begin_value(wi), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), ilo, ihi, + bindings::begin_value(scale), abnrm, + bindings::begin_value(rconde), bindings::begin_value(rcondv), + &opt_size_work, -1, bindings::begin_value(tmp_iwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( balanc, jobvl, jobvr, sense, a, wr, wi, vl, vr, ilo, + ihi, scale, abnrm, rconde, rcondv, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char sense, const char jobvl, + const char jobvr, const std::ptrdiff_t n ) { + if ( sense == 'N' || sense == 'E' ) { + if ( jobvl =='V' || jobvr == 'V' ) + return std::max< std::ptrdiff_t >( 1, 3*n ); + else + return std::max< std::ptrdiff_t >( 1, 2*n ); + } else + return std::max< std::ptrdiff_t >( 1, n*(n+6) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'N' || sense == 'E' ) + return 0; + else + return 2*n-2; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct geevx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename VectorSCALE, typename VectorRCONDE, + typename VectorRCONDV, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, VectorW& w, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace2< + WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) ); + BOOST_ASSERT( bindings::size(rconde) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(rcondv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' || + balanc == 'B' ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' || jobvl == 'E' || + jobvl == 'B' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' || jobvr == 'E' || + jobvr == 'B' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + return detail::geevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(w), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), ilo, + ihi, bindings::begin_value(scale), abnrm, + bindings::begin_value(rconde), bindings::begin_value(rcondv), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename VectorSCALE, typename VectorRCONDE, + typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, VectorW& w, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( sense, + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( balanc, jobvl, jobvr, sense, a, w, vl, vr, ilo, ihi, + scale, abnrm, rconde, rcondv, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename VectorSCALE, typename VectorRCONDE, + typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, VectorW& w, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, real_type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::geevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(w), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), ilo, + ihi, bindings::begin_value(scale), abnrm, + bindings::begin_value(rconde), bindings::begin_value(rcondv), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( balanc, jobvl, jobvr, sense, a, w, vl, vr, ilo, ihi, + scale, abnrm, rconde, rcondv, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'N' || sense == 'E' ) + return std::max< std::ptrdiff_t >( 1, 2*n ); + else + return std::max< std::ptrdiff_t >( 1, n*n + 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the geevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for geevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename VectorSCALE, + typename VectorRCONDE, typename VectorRCONDV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, VectorWR& wr, VectorWI& wi, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, Workspace work ) { + return geevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, wr, wi, + vl, vr, ilo, ihi, scale, abnrm, rconde, rcondv, work ); +} + +// +// Overloaded function for geevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorWR, typename VectorWI, + typename MatrixVL, typename MatrixVR, typename VectorSCALE, + typename VectorRCONDE, typename VectorRCONDV > +inline typename boost::disable_if< detail::is_workspace< VectorRCONDV >, + std::ptrdiff_t >::type +geevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, VectorWR& wr, VectorWI& wi, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorSCALE& scale, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& abnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv ) { + return geevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, wr, wi, + vl, vr, ilo, ihi, scale, abnrm, rconde, rcondv, + optimal_workspace() ); +} + +// +// Overloaded function for geevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename VectorSCALE, typename VectorRCONDE, + typename VectorRCONDV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +geevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, VectorSCALE& scale, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& abnrm, VectorRCONDE& rconde, + VectorRCONDV& rcondv, Workspace work ) { + return geevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, w, vl, + vr, ilo, ihi, scale, abnrm, rconde, rcondv, work ); +} + +// +// Overloaded function for geevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixVL, + typename MatrixVR, typename VectorSCALE, typename VectorRCONDE, + typename VectorRCONDV > +inline typename boost::disable_if< detail::is_workspace< VectorRCONDV >, + std::ptrdiff_t >::type +geevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, VectorW& w, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, VectorSCALE& scale, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& abnrm, VectorRCONDE& rconde, + VectorRCONDV& rcondv ) { + return geevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, w, vl, + vr, ilo, ihi, scale, abnrm, rconde, rcondv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gegv.hpp b/sdk/boost/numeric/bindings/lapack/driver/gegv.hpp new file mode 100644 index 0000000..3ae73a1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gegv.hpp @@ -0,0 +1,509 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gegv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gegv( const char jobvl, const char jobvr, + const fortran_int_t n, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* alphar, float* alphai, float* beta, + float* vl, const fortran_int_t ldvl, float* vr, + const fortran_int_t ldvr, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta, + vl, &ldvl, vr, &ldvr, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gegv( const char jobvl, const char jobvr, + const fortran_int_t n, double* a, const fortran_int_t lda, double* b, + const fortran_int_t ldb, double* alphar, double* alphai, double* beta, + double* vl, const fortran_int_t ldvl, double* vr, + const fortran_int_t ldvr, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta, + vl, &ldvl, vr, &ldvr, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gegv( const char jobvl, const char jobvr, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* alpha, + std::complex* beta, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alpha, beta, vl, + &ldvl, vr, &ldvr, work, &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gegv( const char jobvl, const char jobvr, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* alpha, + std::complex* beta, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGEGV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alpha, beta, vl, + &ldvl, vr, &ldvr, work, &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gegv. +// +template< typename Value, typename Enable = void > +struct gegv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gegv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename WORK > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, + MatrixVR& vr, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + return detail::gegv( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, + MatrixVR& vr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, + MatrixVR& vr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gegv( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr, + workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,8*n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gegv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + return detail::gegv( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( jobvl, jobvr, a, b, alpha, beta, vl, vr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::gegv( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvl, jobvr, a, b, alpha, beta, vl, vr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 8*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gegv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gegv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gegv( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, Workspace work ) { + return gegv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alphar, alphai, + beta, vl, vr, work ); +} + +// +// Overloaded function for gegv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +gegv( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr ) { + return gegv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alphar, alphai, + beta, vl, vr, optimal_workspace() ); +} + +// +// Overloaded function for gegv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gegv( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + Workspace work ) { + return gegv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alpha, beta, vl, + vr, work ); +} + +// +// Overloaded function for gegv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +gegv( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr ) { + return gegv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alpha, beta, vl, + vr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gejsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/gejsv.hpp new file mode 100644 index 0000000..ad2737f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gejsv.hpp @@ -0,0 +1,274 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEJSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GEJSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gejsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gejsv( const char joba, const char jobu, const char jobv, + const char jobr, const char jobt, const char jobp, + const fortran_int_t m, const fortran_int_t n, float* a, + const fortran_int_t lda, float* sva, float* u, + const fortran_int_t ldu, float* v, const fortran_int_t ldv, + float* work, const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGEJSV( &joba, &jobu, &jobv, &jobr, &jobt, &jobp, &m, &n, a, &lda, + sva, u, &ldu, v, &ldv, work, &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gejsv( const char joba, const char jobu, const char jobv, + const char jobr, const char jobt, const char jobp, + const fortran_int_t m, const fortran_int_t n, double* a, + const fortran_int_t lda, double* sva, double* u, + const fortran_int_t ldu, double* v, const fortran_int_t ldv, + double* work, const fortran_int_t lwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGEJSV( &joba, &jobu, &jobv, &jobr, &jobt, &jobp, &m, &n, a, &lda, + sva, u, &ldu, v, &ldv, work, &lwork, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gejsv. +// +template< typename Value > +struct gejsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorSVA, typename MatrixU, + typename MatrixV, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char joba, const char jobu, + const char jobv, const char jobr, const char jobt, + const char jobp, MatrixA& a, VectorSVA& sva, MatrixU& u, + MatrixV& v, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorSVA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorSVA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_row(a), + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( joba, jobu, jobv, bindings::size_row(a), + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::gejsv( joba, jobu, jobv, jobr, jobt, jobp, + bindings::size_row(a), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(sva), bindings::begin_value(u), + bindings::stride_major(u), bindings::begin_value(v), + bindings::stride_major(v), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorSVA, typename MatrixU, + typename MatrixV > + static std::ptrdiff_t invoke( const char joba, const char jobu, + const char jobv, const char jobr, const char jobt, + const char jobp, MatrixA& a, VectorSVA& sva, MatrixU& u, + MatrixV& v, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( joba, + jobu, jobv, bindings::size_row(a), + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_row(a), + bindings::size_column(a) ) ); + return invoke( joba, jobu, jobv, jobr, jobt, jobp, a, sva, u, v, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorSVA, typename MatrixU, + typename MatrixV > + static std::ptrdiff_t invoke( const char joba, const char jobu, + const char jobv, const char jobr, const char jobt, + const char jobp, MatrixA& a, VectorSVA& sva, MatrixU& u, + MatrixV& v, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( joba, jobu, jobv, jobr, jobt, jobp, a, sva, u, v, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char joba, const char jobu, + const char jobv, const std::ptrdiff_t m, const std::ptrdiff_t n ) { + if ( jobu == 'N' && jobv == 'N' ) { + if ( joba != 'E' && joba != 'G' ) + return std::max< std::ptrdiff_t >( std::max< + std::ptrdiff_t >( 2*m+n, 4*n+1), 7 ); + else + return std::max< std::ptrdiff_t >( std::max< + std::ptrdiff_t >( 2*m+n, n*n+4*n), 7 ); + } else if ( jobu == 'N' || jobu == 'W' || jobv == 'N' || + jobv == 'W' ) { + return std::max< std::ptrdiff_t >( 2*n+m, 7); + } else { + if ( jobv != 'J' ) + return 6*n+2*n*n; + else + return std::max< std::ptrdiff_t >( m+3*n+n*n, 7); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t m, + const std::ptrdiff_t n ) { + return m+3*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gejsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gejsv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorSVA, typename MatrixU, + typename MatrixV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gejsv( const char joba, const char jobu, const char jobv, + const char jobr, const char jobt, const char jobp, MatrixA& a, + VectorSVA& sva, MatrixU& u, MatrixV& v, Workspace work ) { + return gejsv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( joba, jobu, jobv, jobr, jobt, jobp, a, + sva, u, v, work ); +} + +// +// Overloaded function for gejsv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorSVA, typename MatrixU, + typename MatrixV > +inline typename boost::disable_if< detail::is_workspace< MatrixV >, + std::ptrdiff_t >::type +gejsv( const char joba, const char jobu, const char jobv, + const char jobr, const char jobt, const char jobp, MatrixA& a, + VectorSVA& sva, MatrixU& u, MatrixV& v ) { + return gejsv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( joba, jobu, jobv, jobr, jobt, jobp, a, + sva, u, v, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gels.hpp b/sdk/boost/numeric/bindings/lapack/driver/gels.hpp new file mode 100644 index 0000000..55fc728 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gels.hpp @@ -0,0 +1,375 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gels is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gels( const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t nrhs, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGELS( &lapack_option< Trans >::value, &m, &n, &nrhs, a, &lda, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gels( const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t nrhs, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGELS( &lapack_option< Trans >::value, &m, &n, &nrhs, a, &lda, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gels( const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGELS( &lapack_option< Trans >::value, &m, &n, &nrhs, a, &lda, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gels( const Trans, const fortran_int_t m, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGELS( &lapack_option< Trans >::value, &m, &n, &nrhs, a, &lda, b, + &ldb, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gels. +// +template< typename Value, typename Enable = void > +struct gels_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gels_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()))) ); + return detail::gels( trans(), bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row_op(a, trans()), bindings::size_column_op(a, + trans()), bindings::size_column(b) ) ); + return invoke( a, b, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + real_type opt_size_work; + detail::gels( trans(), bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t nrhs ) { + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( m, n ); + return std::max< std::ptrdiff_t >( 1, minmn + std::max< + std::ptrdiff_t >( minmn, nrhs ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gels_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()))) ); + return detail::gels( trans(), bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row_op(a, trans()), bindings::size_column_op(a, + trans()), bindings::size_column(b) ) ); + return invoke( a, b, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixB >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + value_type opt_size_work; + detail::gels( trans(), bindings::size_row_op(a, trans()), + bindings::size_column_op(a, trans()), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t nrhs ) { + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( m, n ); + return std::max< std::ptrdiff_t >( 1, minmn + std::max< + std::ptrdiff_t >( minmn, nrhs ) ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gels_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gels. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gels( MatrixA& a, MatrixB& b, Workspace work ) { + return gels_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, work ); +} + +// +// Overloaded function for gels. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB > +inline typename boost::disable_if< detail::is_workspace< MatrixB >, + std::ptrdiff_t >::type +gels( MatrixA& a, MatrixB& b ) { + return gels_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gelsd.hpp b/sdk/boost/numeric/bindings/lapack/driver/gelsd.hpp new file mode 100644 index 0000000..aa10c9c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gelsd.hpp @@ -0,0 +1,493 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gelsd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gelsd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* s, const float rcond, + fortran_int_t& rank, float* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gelsd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* s, const double rcond, + fortran_int_t& rank, double* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelsd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, float* s, const float rcond, + fortran_int_t& rank, std::complex* work, + const fortran_int_t lwork, float* rwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_CGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, rwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelsd( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, const std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, double* s, const double rcond, + fortran_int_t& rank, std::complex* work, + const fortran_int_t lwork, double* rwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_ZGELSD( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, rwork, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gelsd. +// +template< typename Value, typename Enable = void > +struct gelsd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gelsd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorS, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", ""); + std::ptrdiff_t nlvl = std::max< + std::ptrdiff_t >( static_cast(std::log( + static_cast(minmn)/static_cast(smlsiz+ + 1))/std::log(2.0)) + 1, 0 ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( minmn, nlvl )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( minmn, smlsiz, nlvl, + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a))) ); + return detail::gelsd( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", ""); + std::ptrdiff_t nlvl = std::max< + std::ptrdiff_t >( static_cast(std::log( + static_cast(minmn)/static_cast(smlsiz+ + 1))/std::log(2.0)) + 1, 0 ); + bindings::detail::array< real_type > tmp_work( min_size_work( minmn, + smlsiz, nlvl, bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn, nlvl ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", ""); + std::ptrdiff_t nlvl = std::max< + std::ptrdiff_t >( static_cast(std::log( + static_cast(minmn)/static_cast(smlsiz+ + 1))/std::log(2.0)) + 1, 0 ); + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn, nlvl ) ); + detail::gelsd( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, &opt_size_work, -1, bindings::begin_value(tmp_iwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t minmn, + const std::ptrdiff_t smlsiz, const std::ptrdiff_t nlvl, + const std::ptrdiff_t nrhs ) { + std::ptrdiff_t smlsiz_plus_one = smlsiz + 1; + return std::max< std::ptrdiff_t >( 1, 12*minmn + 2*minmn*smlsiz + + 8*minmn*nlvl + minmn*nrhs + + smlsiz_plus_one * smlsiz_plus_one ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t minmn, + const std::ptrdiff_t nlvl ) { + return std::max< std::ptrdiff_t >( 1, 3*minmn*nlvl + 11*minmn ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gelsd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorS, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", ""); + std::ptrdiff_t nlvl = std::max< + std::ptrdiff_t >( static_cast(std::log( + static_cast(minmn)/static_cast(smlsiz+ + 1))/std::log(2.0)) + 1, 0 ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( minmn, nlvl )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( minmn, smlsiz, nlvl, + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), minmn, + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a))) ); + return detail::gelsd( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", ""); + std::ptrdiff_t nlvl = std::max< + std::ptrdiff_t >( static_cast(std::log( + static_cast(minmn)/static_cast(smlsiz+ + 1))/std::log(2.0)) + 1, 0 ); + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), minmn, bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn, + smlsiz, nlvl, bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn, nlvl ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + std::ptrdiff_t smlsiz = ilaenv(9, "GELSD", ""); + std::ptrdiff_t nlvl = std::max< + std::ptrdiff_t >( static_cast(std::log( + static_cast(minmn)/static_cast(smlsiz+ + 1))/std::log(2.0)) + 1, 0 ); + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn, + smlsiz, nlvl, bindings::size_column(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn, nlvl ) ); + detail::gelsd( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, &opt_size_work, -1, bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_iwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t minmn, const std::ptrdiff_t nrhs ) { + return std::max< std::ptrdiff_t >( 1, 2*minmn + std::max< + std::ptrdiff_t >( n, minmn*nrhs ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t minmn, + const std::ptrdiff_t smlsiz, const std::ptrdiff_t nlvl, + const std::ptrdiff_t nrhs ) { + std::ptrdiff_t smlsiz_plus_one = smlsiz + 1; + return std::max< std::ptrdiff_t >( 1, 10*minmn + 2*minmn*smlsiz + + 8*minmn*nlvl + 3*smlsiz*nrhs + + smlsiz_plus_one * smlsiz_plus_one ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t minmn, + const std::ptrdiff_t nlvl ) { + return std::max< std::ptrdiff_t >( 1, 3*minmn*nlvl + 11*minmn ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gelsd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gelsd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorS, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gelsd( MatrixA& a, MatrixB& b, VectorS& s, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type rcond, fortran_int_t& rank, + Workspace work ) { + return gelsd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, s, rcond, rank, work ); +} + +// +// Overloaded function for gelsd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorS > +inline typename boost::disable_if< detail::is_workspace< VectorS >, + std::ptrdiff_t >::type +gelsd( MatrixA& a, MatrixB& b, VectorS& s, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type rcond, fortran_int_t& rank ) { + return gelsd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, s, rcond, rank, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gelss.hpp b/sdk/boost/numeric/bindings/lapack/driver/gelss.hpp new file mode 100644 index 0000000..0134612 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gelss.hpp @@ -0,0 +1,415 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSS_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gelss is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gelss( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* s, const float rcond, + fortran_int_t& rank, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gelss( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* s, const double rcond, + fortran_int_t& rank, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelss( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, float* s, const float rcond, + fortran_int_t& rank, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelss( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, double* s, const double rcond, + fortran_int_t& rank, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGELSS( &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, &rank, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gelss. +// +template< typename Value, typename Enable = void > +struct gelss_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gelss_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorS, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a))) ); + return detail::gelss( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gelss( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t nrhs ) { + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( m, n ); + return std::max< std::ptrdiff_t >( 1, 3*minmn + std::max< + std::ptrdiff_t >( std::max< std::ptrdiff_t >( 2*minmn, std::max< + std::ptrdiff_t >(m,n) ), nrhs ) ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gelss_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorS, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( minmn )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b), minmn )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a))) ); + return detail::gelss( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), minmn ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + minmn ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorS > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorS& s, + const real_type rcond, fortran_int_t& rank, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + minmn ) ); + detail::gelss( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(s), rcond, + rank, &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, s, rcond, rank, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t nrhs, + const std::ptrdiff_t minmn ) { + return std::max< std::ptrdiff_t >( 1, 2*minmn + std::max< + std::ptrdiff_t >( std::max< std::ptrdiff_t >( m,n ), nrhs ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t minmn ) { + return 5*minmn; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gelss_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gelss. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorS, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gelss( MatrixA& a, MatrixB& b, VectorS& s, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type rcond, fortran_int_t& rank, + Workspace work ) { + return gelss_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, s, rcond, rank, work ); +} + +// +// Overloaded function for gelss. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorS > +inline typename boost::disable_if< detail::is_workspace< VectorS >, + std::ptrdiff_t >::type +gelss( MatrixA& a, MatrixB& b, VectorS& s, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type rcond, fortran_int_t& rank ) { + return gelss_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, s, rcond, rank, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gelsy.hpp b/sdk/boost/numeric/bindings/lapack/driver/gelsy.hpp new file mode 100644 index 0000000..901c169 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gelsy.hpp @@ -0,0 +1,400 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSY_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GELSY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gelsy is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gelsy( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, fortran_int_t* jpvt, const float rcond, + fortran_int_t& rank, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gelsy( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, fortran_int_t* jpvt, + const double rcond, fortran_int_t& rank, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelsy( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, fortran_int_t* jpvt, const float rcond, + fortran_int_t& rank, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gelsy( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, fortran_int_t* jpvt, const double rcond, + fortran_int_t& rank, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGELSY( &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, &rank, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gelsy. +// +template< typename Value, typename Enable = void > +struct gelsy_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gelsy_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorJPVT, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const real_type rcond, fortran_int_t& rank, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a))) ); + return detail::gelsy( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(jpvt), rcond, + rank, bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorJPVT > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const real_type rcond, fortran_int_t& rank, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorJPVT > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const real_type rcond, fortran_int_t& rank, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gelsy( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(jpvt), rcond, + rank, &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t nrhs ) { + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( m, n ); + return std::max< std::ptrdiff_t >( 1, std::max< std::ptrdiff_t >( minmn+ + 3*n+1, 2*minmn+nrhs )); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gelsy_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorJPVT, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const real_type rcond, fortran_int_t& rank, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorJPVT >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + std::max< std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a))) ); + return detail::gelsy( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(jpvt), rcond, + rank, bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorJPVT > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const real_type rcond, fortran_int_t& rank, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorJPVT > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const real_type rcond, fortran_int_t& rank, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::gelsy( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(jpvt), rcond, + rank, &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, jpvt, rcond, rank, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t nrhs ) { + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( m, n ); + return std::max< std::ptrdiff_t >( 1, std::max< + std::ptrdiff_t >( std::max< std::ptrdiff_t >( 2*minmn, n+1 ), + minmn+nrhs ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gelsy_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gelsy. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorJPVT, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gelsy( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type rcond, fortran_int_t& rank, + Workspace work ) { + return gelsy_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, jpvt, rcond, rank, work ); +} + +// +// Overloaded function for gelsy. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorJPVT > +inline typename boost::disable_if< detail::is_workspace< VectorJPVT >, + std::ptrdiff_t >::type +gelsy( MatrixA& a, MatrixB& b, VectorJPVT& jpvt, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type rcond, fortran_int_t& rank ) { + return gelsy_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, jpvt, rcond, rank, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gesdd.hpp b/sdk/boost/numeric/bindings/lapack/driver/gesdd.hpp new file mode 100644 index 0000000..fa6b54a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gesdd.hpp @@ -0,0 +1,465 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESDD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESDD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gesdd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gesdd( const char jobz, const fortran_int_t m, + const fortran_int_t n, float* a, const fortran_int_t lda, float* s, + float* u, const fortran_int_t ldu, float* vt, + const fortran_int_t ldvt, float* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gesdd( const char jobz, const fortran_int_t m, + const fortran_int_t n, double* a, const fortran_int_t lda, double* s, + double* u, const fortran_int_t ldu, double* vt, + const fortran_int_t ldvt, double* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gesdd( const char jobz, const fortran_int_t m, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, float* s, std::complex* u, + const fortran_int_t ldu, std::complex* vt, + const fortran_int_t ldvt, std::complex* work, + const fortran_int_t lwork, float* rwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_CGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, + &lwork, rwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gesdd( const char jobz, const fortran_int_t m, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, double* s, std::complex* u, + const fortran_int_t ldu, std::complex* vt, + const fortran_int_t ldvt, std::complex* work, + const fortran_int_t lwork, double* rwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_ZGESDD( &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, + &lwork, rwork, iwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gesdd. +// +template< typename Value, typename Enable = void > +struct gesdd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gesdd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( minmn )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), jobz, minmn )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( jobz == 'A' || jobz == 'S' || jobz == 'O' || + jobz == 'N' ); + return detail::gesdd( jobz, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), jobz, + minmn ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn ) ); + return invoke( jobz, a, s, u, vt, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobz, a, s, u, vt, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const char jobz, + const std::ptrdiff_t minmn ) { + if ( n == 0 ) return 1; + if ( jobz == 'N' ) return 3*minmn + std::max< + std::ptrdiff_t >( std::max< std::ptrdiff_t >(m,n), 7*minmn ); + if ( jobz == 'O' ) return 3*minmn*minmn + std::max< + std::ptrdiff_t >( std::max< std::ptrdiff_t >( m,n ), + 5*minmn*minmn + 4*minmn ); + return 3*minmn*minmn + std::max< std::ptrdiff_t >( std::max< + std::ptrdiff_t >( m,n ), 4*minmn*minmn + 4*minmn ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t minmn ) { + return 8*minmn; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gesdd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT, typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( minmn )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( minmn, jobz )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), jobz, minmn )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( jobz == 'A' || jobz == 'S' || jobz == 'O' || + jobz == 'N' ); + return detail::gesdd( jobz, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), jobz, + minmn ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn, + jobz ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn ) ); + return invoke( jobz, a, s, u, vt, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( minmn, + jobz ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( minmn ) ); + detail::gesdd( jobz, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + &opt_size_work, -1, bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_iwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, a, s, u, vt, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const char jobz, + const std::ptrdiff_t minmn ) { + if ( n == 0 ) return 1; + if ( jobz == 'N' ) return 2*minmn + std::max< std::ptrdiff_t >( m,n ); + if ( jobz == 'O' ) return 2*(minmn*minmn + minmn) + std::max< + std::ptrdiff_t >( m, n ); + return minmn*minmn + 2*minmn + std::max< std::ptrdiff_t >( m, n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t minmn, + const char jobz ) { + if ( jobz == 'N' ) return 5*minmn; + return 5*minmn*minmn + 7*minmn; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t minmn ) { + return 8*minmn; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gesdd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gesdd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gesdd( const char jobz, MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + Workspace work ) { + return gesdd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, s, u, vt, work ); +} + +// +// Overloaded function for gesdd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > +inline typename boost::disable_if< detail::is_workspace< MatrixVT >, + std::ptrdiff_t >::type +gesdd( const char jobz, MatrixA& a, VectorS& s, MatrixU& u, + MatrixVT& vt ) { + return gesdd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, s, u, vt, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gesv.hpp b/sdk/boost/numeric/bindings/lapack/driver/gesv.hpp new file mode 100644 index 0000000..5fd564d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gesv.hpp @@ -0,0 +1,242 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gesv is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const int n, const int nrhs, float* a, + const int lda, int* ipiv, float* b, const int ldb ) { + return clapack_sgesv( clapack_option< Order >::value, n, nrhs, a, lda, + ipiv, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const int n, const int nrhs, double* a, + const int lda, int* ipiv, double* b, const int ldb ) { + return clapack_dgesv( clapack_option< Order >::value, n, nrhs, a, lda, + ipiv, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const int n, const int nrhs, + std::complex* a, const int lda, int* ipiv, + std::complex* b, const int ldb ) { + return clapack_cgesv( clapack_option< Order >::value, n, nrhs, a, lda, + ipiv, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const int n, const int nrhs, + std::complex* a, const int lda, int* ipiv, + std::complex* b, const int ldb ) { + return clapack_zgesv( clapack_option< Order >::value, n, nrhs, a, lda, + ipiv, b, ldb ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, + fortran_int_t* ipiv, float* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + fortran_int_t* ipiv, double* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order > +inline std::ptrdiff_t gesv( Order, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gesv. +// +template< typename Value > +struct gesv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::gesv( order(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gesv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gesv. Its overload differs for +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t gesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) { + return gesv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gesvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/gesvd.hpp new file mode 100644 index 0000000..a907a5d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gesvd.hpp @@ -0,0 +1,470 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gesvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gesvd( const char jobu, const char jobvt, + const fortran_int_t m, const fortran_int_t n, float* a, + const fortran_int_t lda, float* s, float* u, const fortran_int_t ldu, + float* vt, const fortran_int_t ldvt, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gesvd( const char jobu, const char jobvt, + const fortran_int_t m, const fortran_int_t n, double* a, + const fortran_int_t lda, double* s, double* u, + const fortran_int_t ldu, double* vt, const fortran_int_t ldvt, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, + work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gesvd( const char jobu, const char jobvt, + const fortran_int_t m, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, float* s, std::complex* u, + const fortran_int_t ldu, std::complex* vt, + const fortran_int_t ldvt, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, + work, &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gesvd( const char jobu, const char jobvt, + const fortran_int_t m, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, double* s, std::complex* u, + const fortran_int_t ldu, std::complex* vt, + const fortran_int_t ldvt, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGESVD( &jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, + work, &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gesvd. +// +template< typename Value, typename Enable = void > +struct gesvd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gesvd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT, typename WORK > + static std::ptrdiff_t invoke( const char jobu, const char jobvt, + MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobu, jobvt, bindings::size_row(a), + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( jobu == 'A' || jobu == 'S' || jobu == 'O' || + jobu == 'N' ); + BOOST_ASSERT( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' || + jobvt == 'N' ); + return detail::gesvd( jobu, jobvt, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobu, const char jobvt, + MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( jobu, + jobvt, bindings::size_row(a), bindings::size_column(a) ) ); + return invoke( jobu, jobvt, a, s, u, vt, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobu, const char jobvt, + MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gesvd( jobu, jobvt, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobu, jobvt, a, s, u, vt, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobu, const char jobvt, + const std::ptrdiff_t m, const std::ptrdiff_t n ) { + // + // Contributed by Marco Guazzone + // Also see http://tinyurl.com/5rbpdc5 + // + if ( m == 0 || n == 0 ) { + return 1; + } else if ( m >= n ) { + if ( jobu == 'N' ) { + return 5*n; + } else { + return std::max< std::ptrdiff_t >(3*n+m,5*n); + } + } else { + if ( jobvt == 'N' ) { + return 5*m; + } else { + return std::max< std::ptrdiff_t >(3*m+n,5*m); + } + } + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gesvd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobu, const char jobvt, + MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVT >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVT >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVT >::value) ); + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + BOOST_ASSERT( bindings::size(s) >= std::min< + std::ptrdiff_t >(bindings::size_row(a), + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( minmn )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobu, jobvt, bindings::size_row(a), + bindings::size_column(a), minmn )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(vt) == 1 || + bindings::stride_minor(vt) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( jobu == 'A' || jobu == 'S' || jobu == 'O' || + jobu == 'N' ); + BOOST_ASSERT( jobvt == 'A' || jobvt == 'S' || jobvt == 'O' || + jobvt == 'N' ); + return detail::gesvd( jobu, jobvt, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobu, const char jobvt, + MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + bindings::detail::array< value_type > tmp_work( min_size_work( jobu, + jobvt, bindings::size_row(a), bindings::size_column(a), + minmn ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + minmn ) ); + return invoke( jobu, jobvt, a, s, u, vt, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > + static std::ptrdiff_t invoke( const char jobu, const char jobvt, + MatrixA& a, VectorS& s, MatrixU& u, MatrixVT& vt, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + std::ptrdiff_t minmn = std::min< std::ptrdiff_t >( size_row(a), + size_column(a) ); + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + minmn ) ); + detail::gesvd( jobu, jobvt, bindings::size_row(a), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(s), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(vt), bindings::stride_major(vt), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobu, jobvt, a, s, u, vt, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobu, const char jobvt, + const std::ptrdiff_t m, const std::ptrdiff_t n, + const std::ptrdiff_t minmn ) { + // + // Contributed by Marco Guazzone + // Also see http://tinyurl.com/5rbpdc5 + // + if ( minmn == 0 ) { + return 1; + } else if ( m >= n ) { + if ( jobu == 'N' ) { + return 3*n; + } else { + return 2*n+m; + } + } else { + if ( jobvt == 'N' ) { + return 3*m; + } else { + return 2*m+n; + } + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t minmn ) { + return 5*minmn; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gesvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gesvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gesvd( const char jobu, const char jobvt, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt, Workspace work ) { + return gesvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobvt, a, s, u, vt, work ); +} + +// +// Overloaded function for gesvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorS, typename MatrixU, + typename MatrixVT > +inline typename boost::disable_if< detail::is_workspace< MatrixVT >, + std::ptrdiff_t >::type +gesvd( const char jobu, const char jobvt, MatrixA& a, VectorS& s, + MatrixU& u, MatrixVT& vt ) { + return gesvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobvt, a, s, u, vt, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gesvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/gesvx.hpp new file mode 100644 index 0000000..ebb9390 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gesvx.hpp @@ -0,0 +1,524 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GESVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gesvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gesvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, float* a, + const fortran_int_t lda, float* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, char& equed, float* r, float* c, float* b, + const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float& rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGESVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gesvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, double* a, + const fortran_int_t lda, double* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, char& equed, double* r, double* c, double* b, + const fortran_int_t ldb, double* x, const fortran_int_t ldx, + double& rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGESVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gesvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, char& equed, float* r, float* c, + std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGESVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gesvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, char& equed, double* r, double* c, + std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double& rcond, + double* ferr, double* berr, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGESVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, &equed, r, c, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gesvx. +// +template< typename Value, typename Enable = void > +struct gesvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gesvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' || + equed == 'B' ); + BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' ); + return detail::gesvx( fact, trans(), bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + equed, bindings::begin_value(r), bindings::begin_value(c), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(a, trans()) ) ); + return invoke( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr, + berr, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + return invoke( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr, + berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 4*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gesvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(a, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(a, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(a, trans())) ); + BOOST_ASSERT( equed == 'N' || equed == 'R' || equed == 'C' || + equed == 'B' ); + BOOST_ASSERT( fact == 'F' || fact == 'N' || fact == 'E' ); + return detail::gesvx( fact, trans(), bindings::size_column_op(a, + trans()), bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + equed, bindings::begin_value(r), bindings::begin_value(c), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(a, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(a, trans()) ) ); + return invoke( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr, + berr, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + VectorIPIV& ipiv, char& equed, VectorR& r, VectorC& c, MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixAF >::type order; + typedef typename result_of::trans_tag< MatrixA, order >::type trans; + return invoke( fact, a, af, ipiv, equed, r, c, b, x, rcond, ferr, + berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gesvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gesvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gesvx( const char fact, MatrixA& a, MatrixAF& af, VectorIPIV& ipiv, + char& equed, VectorR& r, VectorC& c, MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return gesvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, ipiv, equed, r, c, b, x, + rcond, ferr, berr, work ); +} + +// +// Overloaded function for gesvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename VectorR, typename VectorC, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +gesvx( const char fact, MatrixA& a, MatrixAF& af, VectorIPIV& ipiv, + char& equed, VectorR& r, VectorC& c, MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) { + return gesvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, ipiv, equed, r, c, b, x, + rcond, ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gges.hpp b/sdk/boost/numeric/bindings/lapack/driver/gges.hpp new file mode 100644 index 0000000..2860a7f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gges.hpp @@ -0,0 +1,580 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGES_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGES_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gges is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gges( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + fortran_int_t& sdim, float* alphar, float* alphai, float* beta, + float* vsl, const fortran_int_t ldvsl, float* vsr, + const fortran_int_t ldvsr, float* work, const fortran_int_t lwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_SGGES( &jobvsl, &jobvsr, &sort, selctg, &n, a, &lda, b, &ldb, + &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, work, + &lwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gges( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + fortran_int_t& sdim, double* alphar, double* alphai, double* beta, + double* vsl, const fortran_int_t ldvsl, double* vsr, + const fortran_int_t ldvsr, double* work, const fortran_int_t lwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_DGGES( &jobvsl, &jobvsr, &sort, selctg, &n, a, &lda, b, &ldb, + &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, work, + &lwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gges( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, fortran_int_t& sdim, + std::complex* alpha, std::complex* beta, + std::complex* vsl, const fortran_int_t ldvsl, + std::complex* vsr, const fortran_int_t ldvsr, + std::complex* work, const fortran_int_t lwork, float* rwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_CGGES( &jobvsl, &jobvsr, &sort, selctg, &n, a, &lda, b, &ldb, + &sdim, alpha, beta, vsl, &ldvsl, vsr, &ldvsr, work, &lwork, rwork, + bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gges( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, fortran_int_t& sdim, + std::complex* alpha, std::complex* beta, + std::complex* vsl, const fortran_int_t ldvsl, + std::complex* vsr, const fortran_int_t ldvsr, + std::complex* work, const fortran_int_t lwork, double* rwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_ZGGES( &jobvsl, &jobvsr, &sort, selctg, &n, a, &lda, b, &ldb, + &sdim, alpha, beta, vsl, &ldvsl, vsr, &ldvsr, work, &lwork, rwork, + bwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gges. +// +template< typename Value, typename Enable = void > +struct gges_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gges_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename WORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr, detail::workspace2< WORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) ); + BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsl) == 1 || + bindings::stride_minor(vsl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsr) == 1 || + bindings::stride_minor(vsr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' ); + BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::gges( jobvsl, jobvsr, sort, selctg, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alphar, + alphai, beta, vsl, vsr, workspace( tmp_work, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::gges( jobvsl, jobvsr, sort, selctg, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), &opt_size_work, -1, + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alphar, + alphai, beta, vsl, vsr, workspace( tmp_work, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + if ( n == 0 ) { + return 1; + } else { + return std::max< std::ptrdiff_t >( 8*n, 6*n + 16 ); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gges_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename WORK, typename RWORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr, detail::workspace3< WORK, RWORK, + BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsl) == 1 || + bindings::stride_minor(vsl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsr) == 1 || + bindings::stride_minor(vsr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' ); + BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::gges( jobvsl, jobvsr, sort, selctg, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alpha, beta, + vsl, vsr, workspace( tmp_work, tmp_rwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::gges( jobvsl, jobvsr, sort, selctg, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), &opt_size_work, -1, + bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvsl, jobvsr, sort, selctg, a, b, sdim, alpha, beta, + vsl, vsr, workspace( tmp_work, tmp_rwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gges_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gges. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gges( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, MatrixA& a, MatrixB& b, fortran_int_t& sdim, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr, Workspace work ) { + return gges_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, a, b, + sdim, alphar, alphai, beta, vsl, vsr, work ); +} + +// +// Overloaded function for gges. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR > +inline typename boost::disable_if< detail::is_workspace< MatrixVSR >, + std::ptrdiff_t >::type +gges( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, MatrixA& a, MatrixB& b, fortran_int_t& sdim, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr ) { + return gges_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, a, b, + sdim, alphar, alphai, beta, vsl, vsr, optimal_workspace() ); +} + +// +// Overloaded function for gges. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gges( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, MatrixA& a, MatrixB& b, fortran_int_t& sdim, + VectorALPHA& alpha, VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, + Workspace work ) { + return gges_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, a, b, + sdim, alpha, beta, vsl, vsr, work ); +} + +// +// Overloaded function for gges. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR > +inline typename boost::disable_if< detail::is_workspace< MatrixVSR >, + std::ptrdiff_t >::type +gges( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, MatrixA& a, MatrixB& b, fortran_int_t& sdim, + VectorALPHA& alpha, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr ) { + return gges_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, a, b, + sdim, alpha, beta, vsl, vsr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ggesx.hpp b/sdk/boost/numeric/bindings/lapack/driver/ggesx.hpp new file mode 100644 index 0000000..fa3ad97 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ggesx.hpp @@ -0,0 +1,683 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGESX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGESX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggesx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggesx( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, + const fortran_int_t n, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, fortran_int_t& sdim, float* alphar, + float* alphai, float* beta, float* vsl, const fortran_int_t ldvsl, + float* vsr, const fortran_int_t ldvsr, float* rconde, float* rcondv, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork, fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_SGGESX( &jobvsl, &jobvsr, &sort, selctg, &sense, &n, a, &lda, b, + &ldb, &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, + rconde, rcondv, work, &lwork, iwork, &liwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggesx( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, + const fortran_int_t n, double* a, const fortran_int_t lda, double* b, + const fortran_int_t ldb, fortran_int_t& sdim, double* alphar, + double* alphai, double* beta, double* vsl, const fortran_int_t ldvsl, + double* vsr, const fortran_int_t ldvsr, double* rconde, + double* rcondv, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_DGGESX( &jobvsl, &jobvsr, &sort, selctg, &sense, &n, a, &lda, b, + &ldb, &sdim, alphar, alphai, beta, vsl, &ldvsl, vsr, &ldvsr, + rconde, rcondv, work, &lwork, iwork, &liwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggesx( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, fortran_int_t& sdim, + std::complex* alpha, std::complex* beta, + std::complex* vsl, const fortran_int_t ldvsl, + std::complex* vsr, const fortran_int_t ldvsr, float* rconde, + float* rcondv, std::complex* work, const fortran_int_t lwork, + float* rwork, fortran_int_t* iwork, const fortran_int_t liwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_CGGESX( &jobvsl, &jobvsr, &sort, selctg, &sense, &n, a, &lda, b, + &ldb, &sdim, alpha, beta, vsl, &ldvsl, vsr, &ldvsr, rconde, + rcondv, work, &lwork, rwork, iwork, &liwork, bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggesx( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, fortran_int_t& sdim, + std::complex* alpha, std::complex* beta, + std::complex* vsl, const fortran_int_t ldvsl, + std::complex* vsr, const fortran_int_t ldvsr, double* rconde, + double* rcondv, std::complex* work, const fortran_int_t lwork, + double* rwork, fortran_int_t* iwork, const fortran_int_t liwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_ZGGESX( &jobvsl, &jobvsr, &sort, selctg, &sense, &n, a, &lda, b, + &ldb, &sdim, alpha, beta, vsl, &ldvsl, vsr, &ldvsr, rconde, + rcondv, work, &lwork, rwork, iwork, &liwork, bwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggesx. +// +template< typename Value, typename Enable = void > +struct ggesx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggesx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename VectorRCONDE, typename VectorRCONDV, + typename WORK, typename IWORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, MatrixA& a, + MatrixB& b, fortran_int_t& sdim, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv, + detail::workspace3< WORK, IWORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) ); + BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsl) == 1 || + bindings::stride_minor(vsl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsr) == 1 || + bindings::stride_minor(vsr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' ); + BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::ggesx( jobvsl, jobvsr, sort, selctg, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), bindings::begin_value(rconde), + bindings::begin_value(rcondv), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, MatrixA& a, + MatrixB& b, fortran_int_t& sdim, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim, + alphar, alphai, beta, vsl, vsr, rconde, rcondv, + workspace( tmp_work, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, MatrixA& a, + MatrixB& b, fortran_int_t& sdim, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVSL& vsl, + MatrixVSR& vsr, VectorRCONDE& rconde, VectorRCONDV& rcondv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::ggesx( jobvsl, jobvsr, sort, selctg, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), bindings::begin_value(rconde), + bindings::begin_value(rcondv), &opt_size_work, -1, + bindings::begin_value(tmp_iwork), -1, + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim, + alphar, alphai, beta, vsl, vsr, rconde, rcondv, + workspace( tmp_work, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char sense ) { + if ( n == 0 ) + return 1; + if ( sense == 'N' ) + return std::max< std::ptrdiff_t >( 8*n, 6*n+16 ); + else + return std::max< std::ptrdiff_t >( 8*n, std::max< + std::ptrdiff_t >( 6*n+16, n*n/2 )); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char sense ) { + if ( sense == 'N' ) + return 1; + else + return std::max< std::ptrdiff_t >( 1, n+6 ); + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggesx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename VectorRCONDE, typename VectorRCONDV, typename WORK, + typename RWORK, typename IWORK, typename BWORK > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, MatrixA& a, + MatrixB& b, fortran_int_t& sdim, VectorALPHA& alpha, + VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, + VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace4< + WORK, RWORK, IWORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVSR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorRCONDE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVSR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVSR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( bindings::size_column(a), sort )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), sense )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsl) == 1 || + bindings::stride_minor(vsl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vsr) == 1 || + bindings::stride_minor(vsr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvsl == 'N' || jobvsl == 'V' ); + BOOST_ASSERT( jobvsr == 'N' || jobvsr == 'V' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + BOOST_ASSERT( sort == 'N' || sort == 'S' ); + return detail::ggesx( jobvsl, jobvsr, sort, selctg, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), bindings::begin_value(rconde), + bindings::begin_value(rcondv), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, MatrixA& a, + MatrixB& b, fortran_int_t& sdim, VectorALPHA& alpha, + VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, + VectorRCONDE& rconde, VectorRCONDV& rcondv, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), sense ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim, alpha, + beta, vsl, vsr, rconde, rcondv, workspace( tmp_work, + tmp_rwork, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char jobvsl, const char jobvsr, + const char sort, external_fp selctg, const char sense, MatrixA& a, + MatrixB& b, fortran_int_t& sdim, VectorALPHA& alpha, + VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, + VectorRCONDE& rconde, VectorRCONDV& rcondv, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a), sense ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + bindings::size_column(a), sort ) ); + detail::ggesx( jobvsl, jobvsr, sort, selctg, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), sdim, bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(vsl), + bindings::stride_major(vsl), bindings::begin_value(vsr), + bindings::stride_major(vsr), bindings::begin_value(rconde), + bindings::begin_value(rcondv), &opt_size_work, -1, + bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_iwork), -1, + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvsl, jobvsr, sort, selctg, sense, a, b, sdim, alpha, + beta, vsl, vsr, rconde, rcondv, workspace( tmp_work, + tmp_rwork, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const char sense ) { + if ( sense == 'N' ) + return std::max< std::ptrdiff_t >( 1, 2*n ); + else + return std::max< std::ptrdiff_t >( 1, std::max< + std::ptrdiff_t >( 2*n, n*n/2 ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n, + const char sense ) { + if ( sense == 'N' ) + return 1; + else + return std::max< std::ptrdiff_t >( 1, n+2 ); + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const std::ptrdiff_t n, + const char sort ) { + if ( sort == 'N' ) + return 0; + else + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggesx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggesx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename VectorRCONDE, typename VectorRCONDV, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggesx( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, const char sense, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, + VectorRCONDE& rconde, VectorRCONDV& rcondv, Workspace work ) { + return ggesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, sense, a, + b, sdim, alphar, alphai, beta, vsl, vsr, rconde, rcondv, work ); +} + +// +// Overloaded function for ggesx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVSL, + typename MatrixVSR, typename VectorRCONDE, typename VectorRCONDV > +inline typename boost::disable_if< detail::is_workspace< VectorRCONDV >, + std::ptrdiff_t >::type +ggesx( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, const char sense, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHAR& alphar, VectorALPHAI& alphai, + VectorBETA& beta, MatrixVSL& vsl, MatrixVSR& vsr, + VectorRCONDE& rconde, VectorRCONDV& rcondv ) { + return ggesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, sense, a, + b, sdim, alphar, alphai, beta, vsl, vsr, rconde, rcondv, + optimal_workspace() ); +} + +// +// Overloaded function for ggesx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename VectorRCONDE, typename VectorRCONDV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggesx( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, const char sense, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr, VectorRCONDE& rconde, + VectorRCONDV& rcondv, Workspace work ) { + return ggesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, sense, a, + b, sdim, alpha, beta, vsl, vsr, rconde, rcondv, work ); +} + +// +// Overloaded function for ggesx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVSL, typename MatrixVSR, + typename VectorRCONDE, typename VectorRCONDV > +inline typename boost::disable_if< detail::is_workspace< VectorRCONDV >, + std::ptrdiff_t >::type +ggesx( const char jobvsl, const char jobvsr, const char sort, + external_fp selctg, const char sense, MatrixA& a, MatrixB& b, + fortran_int_t& sdim, VectorALPHA& alpha, VectorBETA& beta, + MatrixVSL& vsl, MatrixVSR& vsr, VectorRCONDE& rconde, + VectorRCONDV& rcondv ) { + return ggesx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvsl, jobvsr, sort, selctg, sense, a, + b, sdim, alpha, beta, vsl, vsr, rconde, rcondv, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ggev.hpp b/sdk/boost/numeric/bindings/lapack/driver/ggev.hpp new file mode 100644 index 0000000..7d6e162 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ggev.hpp @@ -0,0 +1,509 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggev( const char jobvl, const char jobvr, + const fortran_int_t n, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* alphar, float* alphai, float* beta, + float* vl, const fortran_int_t ldvl, float* vr, + const fortran_int_t ldvr, float* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta, + vl, &ldvl, vr, &ldvr, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggev( const char jobvl, const char jobvr, + const fortran_int_t n, double* a, const fortran_int_t lda, double* b, + const fortran_int_t ldb, double* alphar, double* alphai, double* beta, + double* vl, const fortran_int_t ldvl, double* vr, + const fortran_int_t ldvr, double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alphar, alphai, beta, + vl, &ldvl, vr, &ldvr, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggev( const char jobvl, const char jobvr, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* alpha, + std::complex* beta, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alpha, beta, vl, + &ldvl, vr, &ldvr, work, &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggev( const char jobvl, const char jobvr, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* alpha, + std::complex* beta, std::complex* vl, + const fortran_int_t ldvl, std::complex* vr, + const fortran_int_t ldvr, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGGEV( &jobvl, &jobvr, &n, a, &lda, b, &ldb, alpha, beta, vl, + &ldvl, vr, &ldvr, work, &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggev. +// +template< typename Value, typename Enable = void > +struct ggev_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggev_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename WORK > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, + MatrixVR& vr, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + return detail::ggev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, + MatrixVR& vr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, + MatrixVR& vr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ggev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alphar), bindings::begin_value(alphai), + bindings::begin_value(beta), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvl, jobvr, a, b, alphar, alphai, beta, vl, vr, + workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,8*n); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggev_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + return detail::ggev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( jobvl, jobvr, a, b, alpha, beta, vl, vr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR > + static std::ptrdiff_t invoke( const char jobvl, const char jobvr, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::ggev( jobvl, jobvr, bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobvl, jobvr, a, b, alpha, beta, vl, vr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 8*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggev( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, Workspace work ) { + return ggev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alphar, alphai, + beta, vl, vr, work ); +} + +// +// Overloaded function for ggev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +ggev( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr ) { + return ggev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alphar, alphai, + beta, vl, vr, optimal_workspace() ); +} + +// +// Overloaded function for ggev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggev( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + Workspace work ) { + return ggev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alpha, beta, vl, + vr, work ); +} + +// +// Overloaded function for ggev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR > +inline typename boost::disable_if< detail::is_workspace< MatrixVR >, + std::ptrdiff_t >::type +ggev( const char jobvl, const char jobvr, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr ) { + return ggev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobvl, jobvr, a, b, alpha, beta, vl, + vr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ggevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/ggevx.hpp new file mode 100644 index 0000000..54eeed0 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ggevx.hpp @@ -0,0 +1,756 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + float* alphar, float* alphai, float* beta, float* vl, + const fortran_int_t ldvl, float* vr, const fortran_int_t ldvr, + fortran_int_t& ilo, fortran_int_t& ihi, float* lscale, float* rscale, + float& abnrm, float& bbnrm, float* rconde, float* rcondv, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_SGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb, + alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale, + rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork, iwork, + bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + double* alphar, double* alphai, double* beta, double* vl, + const fortran_int_t ldvl, double* vr, const fortran_int_t ldvr, + fortran_int_t& ilo, fortran_int_t& ihi, double* lscale, + double* rscale, double& abnrm, double& bbnrm, double* rconde, + double* rcondv, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_DGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb, + alphar, alphai, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale, + rscale, &abnrm, &bbnrm, rconde, rcondv, work, &lwork, iwork, + bwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* alpha, std::complex* beta, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, fortran_int_t& ilo, + fortran_int_t& ihi, float* lscale, float* rscale, float& abnrm, + float& bbnrm, float* rconde, float* rcondv, std::complex* work, + const fortran_int_t lwork, float* rwork, fortran_int_t* iwork, + fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_CGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb, + alpha, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale, rscale, + &abnrm, &bbnrm, rconde, rcondv, work, &lwork, rwork, iwork, bwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggevx( const char balanc, const char jobvl, + const char jobvr, const char sense, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, + std::complex* alpha, std::complex* beta, + std::complex* vl, const fortran_int_t ldvl, + std::complex* vr, const fortran_int_t ldvr, + fortran_int_t& ilo, fortran_int_t& ihi, double* lscale, + double* rscale, double& abnrm, double& bbnrm, double* rconde, + double* rcondv, std::complex* work, const fortran_int_t lwork, + double* rwork, fortran_int_t* iwork, fortran_bool_t* bwork ) { + fortran_int_t info(0); + LAPACK_ZGGEVX( &balanc, &jobvl, &jobvr, &sense, &n, a, &lda, b, &ldb, + alpha, beta, vl, &ldvl, vr, &ldvr, &ilo, &ihi, lscale, rscale, + &abnrm, &bbnrm, rconde, rcondv, work, &lwork, rwork, iwork, bwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggevx. +// +template< typename Value, typename Enable = void > +struct ggevx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggevx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV, typename WORK, + typename IWORK, typename BWORK > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, + VectorRSCALE& rscale, real_type& abnrm, real_type& bbnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, detail::workspace3< + WORK, IWORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHAI >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorLSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHAI >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) ); + BOOST_ASSERT( bindings::size(alphai) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(alphar) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( balanc, jobvl, jobvr, sense, + bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' || + balanc == 'B' ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + return detail::ggevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(alphar), + bindings::begin_value(alphai), bindings::begin_value(beta), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), ilo, + ihi, bindings::begin_value(lscale), + bindings::begin_value(rscale), abnrm, bbnrm, + bindings::begin_value(rconde), bindings::begin_value(rcondv), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, + VectorRSCALE& rscale, real_type& abnrm, real_type& bbnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( balanc, + jobvl, jobvr, sense, bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( sense, bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + sense, bindings::size_column(a) ) ); + return invoke( balanc, jobvl, jobvr, sense, a, b, alphar, alphai, + beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, + rcondv, workspace( tmp_work, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, MatrixB& b, + VectorALPHAR& alphar, VectorALPHAI& alphai, VectorBETA& beta, + MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, + VectorRSCALE& rscale, real_type& abnrm, real_type& bbnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( sense, bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + sense, bindings::size_column(a) ) ); + detail::ggevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(alphar), + bindings::begin_value(alphai), bindings::begin_value(beta), + bindings::begin_value(vl), bindings::stride_major(vl), + bindings::begin_value(vr), bindings::stride_major(vr), ilo, + ihi, bindings::begin_value(lscale), + bindings::begin_value(rscale), abnrm, bbnrm, + bindings::begin_value(rconde), bindings::begin_value(rcondv), + &opt_size_work, -1, bindings::begin_value(tmp_iwork), + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( balanc, jobvl, jobvr, sense, a, b, alphar, alphai, + beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, + rcondv, workspace( tmp_work, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char balanc, const char jobvl, + const char jobvr, const char sense, const std::ptrdiff_t n ) { + if ( balanc == 'S' || balanc == 'B' || jobvl == 'V' || jobvr == 'V' ) + return std::max< std::ptrdiff_t >( 1, 6*n ); + if ( sense == 'E' ) + return std::max< std::ptrdiff_t >( 1, 10*n ); + if ( sense == 'V' || sense == 'B' ) + return 2*n*n + 8*n + 16; + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'E' ) + return 0; + else + return n+6; + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'N' ) + return 0; + else + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggevx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV, typename WORK, + typename RWORK, typename IWORK, typename BWORK > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, real_type& abnrm, + real_type& bbnrm, VectorRCONDE& rconde, VectorRCONDV& rcondv, + detail::workspace4< WORK, RWORK, IWORK, BWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRSCALE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorLSCALE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorRCONDV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVL >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixVR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixVR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorLSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRSCALE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorRCONDV >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(beta) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(fortran_bool_t())) >= + min_size_bwork( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( balanc, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( sense, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(vl) == 1 || + bindings::stride_minor(vl) == 1 ); + BOOST_ASSERT( bindings::size_minor(vr) == 1 || + bindings::stride_minor(vr) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( balanc == 'N' || balanc == 'P' || balanc == 'S' || + balanc == 'B' ); + BOOST_ASSERT( jobvl == 'N' || jobvl == 'V' ); + BOOST_ASSERT( jobvr == 'N' || jobvr == 'V' ); + BOOST_ASSERT( sense == 'N' || sense == 'E' || sense == 'V' || + sense == 'B' ); + return detail::ggevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), ilo, ihi, + bindings::begin_value(lscale), bindings::begin_value(rscale), + abnrm, bbnrm, bindings::begin_value(rconde), + bindings::begin_value(rcondv), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(work.select(fortran_bool_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, real_type& abnrm, + real_type& bbnrm, VectorRCONDE& rconde, VectorRCONDV& rcondv, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( sense, + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + balanc, bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( sense, bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + sense, bindings::size_column(a) ) ); + return invoke( balanc, jobvl, jobvr, sense, a, b, alpha, beta, vl, vr, + ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, + workspace( tmp_work, tmp_rwork, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV > + static std::ptrdiff_t invoke( const char balanc, const char jobvl, + const char jobvr, const char sense, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, + VectorLSCALE& lscale, VectorRSCALE& rscale, real_type& abnrm, + real_type& bbnrm, VectorRCONDE& rconde, VectorRCONDV& rcondv, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + balanc, bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( sense, bindings::size_column(a) ) ); + bindings::detail::array< fortran_bool_t > tmp_bwork( min_size_bwork( + sense, bindings::size_column(a) ) ); + detail::ggevx( balanc, jobvl, jobvr, sense, + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(alpha), + bindings::begin_value(beta), bindings::begin_value(vl), + bindings::stride_major(vl), bindings::begin_value(vr), + bindings::stride_major(vr), ilo, ihi, + bindings::begin_value(lscale), bindings::begin_value(rscale), + abnrm, bbnrm, bindings::begin_value(rconde), + bindings::begin_value(rcondv), &opt_size_work, -1, + bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_iwork), + bindings::begin_value(tmp_bwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( balanc, jobvl, jobvr, sense, a, b, alpha, beta, vl, vr, + ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, + workspace( tmp_work, tmp_rwork, tmp_iwork, tmp_bwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'N' ) + return std::max< std::ptrdiff_t >( 1, 2*n ); + else { + if ( sense == 'E' ) + return std::max< std::ptrdiff_t >( 1, 4*n ); + else + return std::max< std::ptrdiff_t >( 1, 2*n*n+2*n ); + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char balanc, + const std::ptrdiff_t n ) { + if ( balanc == 'S' || balanc == 'B' ) + return std::max< std::ptrdiff_t >( 1, 6*n ); + else + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'E' ) + return 0; + else + return n+2; + } + + // + // Static member function that returns the minimum size of + // workspace-array bwork. + // + static std::ptrdiff_t min_size_bwork( const char sense, + const std::ptrdiff_t n ) { + if ( sense == 'N' ) + return 0; + else + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale, + VectorRSCALE& rscale, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& abnrm, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& bbnrm, VectorRCONDE& rconde, + VectorRCONDV& rcondv, Workspace work ) { + return ggevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, b, + alphar, alphai, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, + bbnrm, rconde, rcondv, work ); +} + +// +// Overloaded function for ggevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHAR, + typename VectorALPHAI, typename VectorBETA, typename MatrixVL, + typename MatrixVR, typename VectorLSCALE, typename VectorRSCALE, + typename VectorRCONDE, typename VectorRCONDV > +inline typename boost::disable_if< detail::is_workspace< VectorRCONDV >, + std::ptrdiff_t >::type +ggevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, MatrixB& b, VectorALPHAR& alphar, + VectorALPHAI& alphai, VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, + fortran_int_t& ilo, fortran_int_t& ihi, VectorLSCALE& lscale, + VectorRSCALE& rscale, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& abnrm, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& bbnrm, VectorRCONDE& rconde, + VectorRCONDV& rcondv ) { + return ggevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, b, + alphar, alphai, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, + bbnrm, rconde, rcondv, optimal_workspace() ); +} + +// +// Overloaded function for ggevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename VectorLSCALE, typename VectorRSCALE, typename VectorRCONDE, + typename VectorRCONDV, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, MatrixB& b, VectorALPHA& alpha, + VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& abnrm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& bbnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv, Workspace work ) { + return ggevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, b, + alpha, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, + rconde, rcondv, work ); +} + +// +// Overloaded function for ggevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixVL, typename MatrixVR, + typename VectorLSCALE, typename VectorRSCALE, typename VectorRCONDE, + typename VectorRCONDV > +inline typename boost::disable_if< detail::is_workspace< VectorRCONDV >, + std::ptrdiff_t >::type +ggevx( const char balanc, const char jobvl, const char jobvr, + const char sense, MatrixA& a, MatrixB& b, VectorALPHA& alpha, + VectorBETA& beta, MatrixVL& vl, MatrixVR& vr, fortran_int_t& ilo, + fortran_int_t& ihi, VectorLSCALE& lscale, VectorRSCALE& rscale, + typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type& abnrm, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& bbnrm, + VectorRCONDE& rconde, VectorRCONDV& rcondv ) { + return ggevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( balanc, jobvl, jobvr, sense, a, b, + alpha, beta, vl, vr, ilo, ihi, lscale, rscale, abnrm, bbnrm, + rconde, rcondv, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ggglm.hpp b/sdk/boost/numeric/bindings/lapack/driver/ggglm.hpp new file mode 100644 index 0000000..f5e4c5a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ggglm.hpp @@ -0,0 +1,407 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGGLM_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGGLM_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggglm is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggglm( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* d, float* x, float* y, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggglm( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, double* a, const fortran_int_t lda, double* b, + const fortran_int_t ldb, double* d, double* x, double* y, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggglm( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* d, + std::complex* x, std::complex* y, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggglm( const fortran_int_t n, const fortran_int_t m, + const fortran_int_t p, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* d, + std::complex* x, std::complex* y, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGGGLM( &n, &m, &p, a, &lda, b, &ldb, d, x, y, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggglm. +// +template< typename Value, typename Enable = void > +struct ggglm_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggglm_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d, + VectorX& x, VectorY& y, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(x) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(y) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size_column(b) >= bindings::size_row(a)- + bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ggglm( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(d), + bindings::begin_value(x), bindings::begin_value(y), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d, + VectorX& x, VectorY& y, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + return invoke( a, b, d, x, y, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d, + VectorX& x, VectorY& y, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::ggglm( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(d), + bindings::begin_value(x), bindings::begin_value(y), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, d, x, y, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,n+m+p); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggglm_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d, + VectorX& x, VectorY& y, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorY >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorY >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(x) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(y) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size_column(b) >= bindings::size_row(a)- + bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + return detail::ggglm( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(d), + bindings::begin_value(x), bindings::begin_value(y), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d, + VectorX& x, VectorY& y, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b) ) ); + return invoke( a, b, d, x, y, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorD& d, + VectorX& x, VectorY& y, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::ggglm( bindings::size_row(a), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(d), + bindings::begin_value(x), bindings::begin_value(y), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, d, x, y, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,n+m+p); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggglm_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggglm. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggglm( MatrixA& a, MatrixB& b, VectorD& d, VectorX& x, VectorY& y, + Workspace work ) { + return ggglm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, d, x, y, work ); +} + +// +// Overloaded function for ggglm. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorD, + typename VectorX, typename VectorY > +inline typename boost::disable_if< detail::is_workspace< VectorY >, + std::ptrdiff_t >::type +ggglm( MatrixA& a, MatrixB& b, VectorD& d, VectorX& x, VectorY& y ) { + return ggglm_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, d, x, y, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gglse.hpp b/sdk/boost/numeric/bindings/lapack/driver/gglse.hpp new file mode 100644 index 0000000..80e64d1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gglse.hpp @@ -0,0 +1,405 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGLSE_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGLSE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gglse is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gglse( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t p, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb, float* c, float* d, float* x, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gglse( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t p, double* a, const fortran_int_t lda, double* b, + const fortran_int_t ldb, double* c, double* d, double* x, + double* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gglse( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t p, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* c, + std::complex* d, std::complex* x, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gglse( const fortran_int_t m, const fortran_int_t n, + const fortran_int_t p, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, std::complex* c, + std::complex* d, std::complex* x, + std::complex* work, const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZGGLSE( &m, &n, &p, a, &lda, b, &ldb, c, d, x, work, &lwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gglse. +// +template< typename Value, typename Enable = void > +struct gglse_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gglse_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c, + VectorD& d, VectorX& x, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size(c) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_row(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size(x) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + return detail::gglse( bindings::size_row(a), bindings::size_column(a), + bindings::size_row(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::begin_value(d), bindings::begin_value(x), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c, + VectorD& d, VectorX& x, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_row(b) ) ); + return invoke( a, b, c, d, x, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c, + VectorD& d, VectorX& x, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + detail::gglse( bindings::size_row(a), bindings::size_column(a), + bindings::size_row(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::begin_value(d), bindings::begin_value(x), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, c, d, x, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,m+n+p); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gglse_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX, typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c, + VectorD& d, VectorX& x, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorC >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorC >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorX >::value) ); + BOOST_ASSERT( bindings::size(c) >= bindings::size_row(a) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_row(b) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_row(a), + bindings::size_column(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size(x) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + return detail::gglse( bindings::size_row(a), bindings::size_column(a), + bindings::size_row(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::begin_value(d), bindings::begin_value(x), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c, + VectorD& d, VectorX& x, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_row(a), bindings::size_column(a), + bindings::size_row(b) ) ); + return invoke( a, b, c, d, x, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b, VectorC& c, + VectorD& d, VectorX& x, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + value_type opt_size_work; + detail::gglse( bindings::size_row(a), bindings::size_column(a), + bindings::size_row(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(c), + bindings::begin_value(d), bindings::begin_value(x), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, b, c, d, x, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t m, + const std::ptrdiff_t n, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(1,m+n+p); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gglse_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gglse. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gglse( MatrixA& a, MatrixB& b, VectorC& c, VectorD& d, VectorX& x, + Workspace work ) { + return gglse_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, c, d, x, work ); +} + +// +// Overloaded function for gglse. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorC, + typename VectorD, typename VectorX > +inline typename boost::disable_if< detail::is_workspace< VectorX >, + std::ptrdiff_t >::type +gglse( MatrixA& a, MatrixB& b, VectorC& c, VectorD& d, VectorX& x ) { + return gglse_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, c, d, x, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ggsvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/ggsvd.hpp new file mode 100644 index 0000000..2277895 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ggsvd.hpp @@ -0,0 +1,514 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGSVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GGSVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ggsvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ggsvd( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t p, + fortran_int_t& k, fortran_int_t& l, float* a, const fortran_int_t lda, + float* b, const fortran_int_t ldb, float* alpha, float* beta, + float* u, const fortran_int_t ldu, float* v, const fortran_int_t ldv, + float* q, const fortran_int_t ldq, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b, &ldb, + alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ggsvd( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t p, + fortran_int_t& k, fortran_int_t& l, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + double* alpha, double* beta, double* u, const fortran_int_t ldu, + double* v, const fortran_int_t ldv, double* q, + const fortran_int_t ldq, double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b, &ldb, + alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggsvd( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t p, + fortran_int_t& k, fortran_int_t& l, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, float* alpha, float* beta, + std::complex* u, const fortran_int_t ldu, + std::complex* v, const fortran_int_t ldv, + std::complex* q, const fortran_int_t ldq, + std::complex* work, float* rwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_CGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b, &ldb, + alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, rwork, iwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ggsvd( const char jobu, const char jobv, const char jobq, + const fortran_int_t m, const fortran_int_t n, const fortran_int_t p, + fortran_int_t& k, fortran_int_t& l, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, double* alpha, double* beta, + std::complex* u, const fortran_int_t ldu, + std::complex* v, const fortran_int_t ldv, + std::complex* q, const fortran_int_t ldq, + std::complex* work, double* rwork, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_ZGGSVD( &jobu, &jobv, &jobq, &m, &n, &p, &k, &l, a, &lda, b, &ldb, + alpha, beta, u, &ldu, v, &ldv, q, &ldq, work, rwork, iwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ggsvd. +// +template< typename Value, typename Enable = void > +struct ggsvd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ggsvd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, fortran_int_t& k, fortran_int_t& l, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorALPHA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_row(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + BOOST_ASSERT( jobq == 'Q' || jobq == 'N' ); + BOOST_ASSERT( jobu == 'U' || jobu == 'N' ); + BOOST_ASSERT( jobv == 'V' || jobv == 'N' ); + return detail::ggsvd( jobu, jobv, jobq, bindings::size_row(a), + bindings::size_column(a), bindings::size_row(b), k, l, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(v), bindings::stride_major(v), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, fortran_int_t& k, fortran_int_t& l, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_row(a), + bindings::size_row(b) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, fortran_int_t& k, fortran_int_t& l, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(3*n,std::max< std::ptrdiff_t >(m,p))+n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ggsvd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ, typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, fortran_int_t& k, fortran_int_t& l, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, detail::workspace3< WORK, + RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorALPHA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBETA >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixV >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorALPHA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBETA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_ASSERT( bindings::size(alpha) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_row(a), bindings::size_row(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(u) == 1 || + bindings::stride_minor(u) == 1 ); + BOOST_ASSERT( bindings::size_minor(v) == 1 || + bindings::stride_minor(v) == 1 ); + BOOST_ASSERT( bindings::size_row(a) >= 0 ); + BOOST_ASSERT( bindings::size_row(b) >= 0 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_row(b)) ); + BOOST_ASSERT( jobq == 'Q' || jobq == 'N' ); + BOOST_ASSERT( jobu == 'U' || jobu == 'N' ); + BOOST_ASSERT( jobv == 'V' || jobv == 'N' ); + return detail::ggsvd( jobu, jobv, jobq, bindings::size_row(a), + bindings::size_column(a), bindings::size_row(b), k, l, + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(alpha), bindings::begin_value(beta), + bindings::begin_value(u), bindings::stride_major(u), + bindings::begin_value(v), bindings::stride_major(v), + bindings::begin_value(q), bindings::stride_major(q), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, fortran_int_t& k, fortran_int_t& l, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_row(a), + bindings::size_row(b) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q, + workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > + static std::ptrdiff_t invoke( const char jobu, const char jobv, + const char jobq, fortran_int_t& k, fortran_int_t& l, + MatrixA& a, MatrixB& b, VectorALPHA& alpha, VectorBETA& beta, + MatrixU& u, MatrixV& v, MatrixQ& q, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobu, jobv, jobq, k, l, a, b, alpha, beta, u, v, q, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t m, const std::ptrdiff_t p ) { + return std::max< std::ptrdiff_t >(3*n,std::max< std::ptrdiff_t >(m,p))+n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ggsvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ggsvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ggsvd( const char jobu, const char jobv, const char jobq, + fortran_int_t& k, fortran_int_t& l, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixU& u, MatrixV& v, + MatrixQ& q, Workspace work ) { + return ggsvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobv, jobq, k, l, a, b, alpha, + beta, u, v, q, work ); +} + +// +// Overloaded function for ggsvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorALPHA, + typename VectorBETA, typename MatrixU, typename MatrixV, + typename MatrixQ > +inline typename boost::disable_if< detail::is_workspace< MatrixQ >, + std::ptrdiff_t >::type +ggsvd( const char jobu, const char jobv, const char jobq, + fortran_int_t& k, fortran_int_t& l, MatrixA& a, MatrixB& b, + VectorALPHA& alpha, VectorBETA& beta, MatrixU& u, MatrixV& v, + MatrixQ& q ) { + return ggsvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobu, jobv, jobq, k, l, a, b, alpha, + beta, u, v, q, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gtsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/gtsv.hpp new file mode 100644 index 0000000..a829d9d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gtsv.hpp @@ -0,0 +1,181 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GTSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GTSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gtsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t gtsv( const fortran_int_t n, const fortran_int_t nrhs, + float* dl, float* d, float* du, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t gtsv( const fortran_int_t n, const fortran_int_t nrhs, + double* dl, double* d, double* du, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gtsv( const fortran_int_t n, const fortran_int_t nrhs, + std::complex* dl, std::complex* d, + std::complex* du, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t gtsv( const fortran_int_t n, const fortran_int_t nrhs, + std::complex* dl, std::complex* d, + std::complex* du, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZGTSV( &n, &nrhs, dl, d, du, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gtsv. +// +template< typename Value > +struct gtsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename MatrixB > + static std::ptrdiff_t invoke( const fortran_int_t n, VectorDL& dl, + VectorD& d, VectorDU& du, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDL >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDU >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(dl) >= n-1 ); + BOOST_ASSERT( bindings::size(du) >= n-1 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + n) ); + BOOST_ASSERT( n >= 0 ); + return detail::gtsv( n, bindings::size_column(b), + bindings::begin_value(dl), bindings::begin_value(d), + bindings::begin_value(du), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gtsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gtsv. Its overload differs for +// +template< typename VectorDL, typename VectorD, typename VectorDU, + typename MatrixB > +inline std::ptrdiff_t gtsv( const fortran_int_t n, VectorDL& dl, + VectorD& d, VectorDU& du, MatrixB& b ) { + return gtsv_impl< typename bindings::value_type< + VectorDL >::type >::invoke( n, dl, d, du, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/gtsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/gtsvx.hpp new file mode 100644 index 0000000..7f6b2ff --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/gtsvx.hpp @@ -0,0 +1,556 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GTSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_GTSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for gtsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, const float* dl, + const float* d, const float* du, float* dlf, float* df, float* duf, + float* du2, fortran_int_t* ipiv, const float* b, + const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float& rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SGTSVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, dl, d, + du, dlf, df, duf, du2, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, const double* dl, + const double* d, const double* du, double* dlf, double* df, + double* duf, double* du2, fortran_int_t* ipiv, const double* b, + const fortran_int_t ldb, double* x, const fortran_int_t ldx, + double& rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DGTSVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, dl, d, + du, dlf, df, duf, du2, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, + work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* dl, const std::complex* d, + const std::complex* du, std::complex* dlf, + std::complex* df, std::complex* duf, + std::complex* du2, fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CGTSVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, dl, d, + du, dlf, df, duf, du2, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, + work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Trans > +inline std::ptrdiff_t gtsvx( const char fact, const Trans, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* dl, const std::complex* d, + const std::complex* du, std::complex* dlf, + std::complex* df, std::complex* duf, + std::complex* du2, fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double& rcond, + double* ferr, double* berr, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZGTSVX( &fact, &lapack_option< Trans >::value, &n, &nrhs, dl, d, + du, dlf, df, duf, du2, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, + work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to gtsvx. +// +template< typename Value, typename Enable = void > +struct gtsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct gtsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, const VectorDL& dl, + const VectorD& d, const VectorDU& du, VectorDLF& dlf, + VectorDF& df, VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, + VectorBERR& berr, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDLF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDUF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDLF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDUF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDU2 >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(dl) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(d, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::gtsvx( fact, trans(), bindings::size_column_op(d, + trans()), bindings::size_column(b), bindings::begin_value(dl), + bindings::begin_value(d), bindings::begin_value(du), + bindings::begin_value(dlf), bindings::begin_value(df), + bindings::begin_value(duf), bindings::begin_value(du2), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), rcond, bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorDL& dl, + const VectorD& d, const VectorDU& du, VectorDLF& dlf, + VectorDF& df, VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, + VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column_op(d, trans()) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column_op(d, trans()) ) ); + return invoke( fact, dl, d, du, dlf, df, duf, du2, ipiv, b, x, rcond, + ferr, berr, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorDL& dl, + const VectorD& d, const VectorDU& du, VectorDLF& dlf, + VectorDF& df, VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, + VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + return invoke( fact, dl, d, du, dlf, df, duf, du2, ipiv, b, x, rcond, + ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct gtsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, const VectorDL& dl, + const VectorD& d, const VectorDU& du, VectorDLF& dlf, + VectorDF& df, VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, + VectorBERR& berr, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorD >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDLF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDUF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDU2 >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorDL >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDLF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDUF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDU2 >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size_column_op(d, + trans()) ); + BOOST_ASSERT( bindings::size(dl) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(du) >= bindings::size_column_op(d, + trans())-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column_op(d, trans()) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_column_op(d, trans()) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column_op(d, trans())) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::gtsvx( fact, trans(), bindings::size_column_op(d, + trans()), bindings::size_column(b), bindings::begin_value(dl), + bindings::begin_value(d), bindings::begin_value(du), + bindings::begin_value(dlf), bindings::begin_value(df), + bindings::begin_value(duf), bindings::begin_value(du2), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), rcond, bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorDL& dl, + const VectorD& d, const VectorDU& du, VectorDLF& dlf, + VectorDF& df, VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, + VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column_op(d, trans()) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column_op(d, trans()) ) ); + return invoke( fact, dl, d, du, dlf, df, duf, du2, ipiv, b, x, rcond, + ferr, berr, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorDL& dl, + const VectorD& d, const VectorDU& du, VectorDLF& dlf, + VectorDF& df, VectorDUF& duf, VectorDU2& du2, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, real_type& rcond, VectorFERR& ferr, + VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef tag::column_major order; + typedef typename result_of::trans_tag< VectorD, order >::type trans; + return invoke( fact, dl, d, du, dlf, df, duf, du2, ipiv, b, x, rcond, + ferr, berr, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the gtsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for gtsvx. Its overload differs for +// * User-defined workspace +// +template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +gtsvx( const char fact, const VectorDL& dl, const VectorD& d, + const VectorDU& du, VectorDLF& dlf, VectorDF& df, VectorDUF& duf, + VectorDU2& du2, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + VectorDL >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return gtsvx_impl< typename bindings::value_type< + VectorDL >::type >::invoke( fact, dl, d, du, dlf, df, duf, du2, + ipiv, b, x, rcond, ferr, berr, work ); +} + +// +// Overloaded function for gtsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorDL, typename VectorD, typename VectorDU, + typename VectorDLF, typename VectorDF, typename VectorDUF, + typename VectorDU2, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +gtsvx( const char fact, const VectorDL& dl, const VectorD& d, + const VectorDU& du, VectorDLF& dlf, VectorDF& df, VectorDUF& duf, + VectorDU2& du2, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + VectorDL >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) { + return gtsvx_impl< typename bindings::value_type< + VectorDL >::type >::invoke( fact, dl, d, du, dlf, df, duf, du2, + ipiv, b, x, rcond, ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hbev.hpp b/sdk/boost/numeric/bindings/lapack/driver/hbev.hpp new file mode 100644 index 0000000..1236309 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hbev.hpp @@ -0,0 +1,358 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbev( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t kd, float* ab, const fortran_int_t ldab, float* w, + float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSBEV( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, w, + z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbev( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t kd, double* ab, const fortran_int_t ldab, + double* w, double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSBEV( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, w, + z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbev( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t kd, std::complex* ab, + const fortran_int_t ldab, float* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHBEV( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, w, + z, &ldz, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbev( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t kd, std::complex* ab, + const fortran_int_t ldab, double* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHBEV( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, w, + z, &ldz, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbev. +// +template< typename Value, typename Enable = void > +struct hbev_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbev_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbev( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( jobz, ab, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, ab, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-2); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbev_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbev( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, ab, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-2); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbev( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z, + Workspace work ) { + return hbev_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, work ); +} + +// +// Overloaded function for hbev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hbev( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z ) { + return hbev_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hbevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/hbevd.hpp new file mode 100644 index 0000000..1e14914 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hbevd.hpp @@ -0,0 +1,459 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t kd, float* ab, + const fortran_int_t ldab, float* w, float* z, const fortran_int_t ldz, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSBEVD( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t kd, double* ab, + const fortran_int_t ldab, double* w, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSBEVD( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + std::complex* ab, const fortran_int_t ldab, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, float* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHBEVD( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + w, z, &ldz, work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + std::complex* ab, const fortran_int_t ldab, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, double* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHBEVD( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + w, z, &ldz, work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbevd. +// +template< typename Value, typename Enable = void > +struct hbevd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbevd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbevd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ab) ) ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::hbevd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbevd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbevd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ab) ) ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::hbevd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbevd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbevd( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z, + Workspace work ) { + return hbevd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, work ); +} + +// +// Overloaded function for hbevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hbevd( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z ) { + return hbevd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hbevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hbevx.hpp new file mode 100644 index 0000000..c1db14b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hbevx.hpp @@ -0,0 +1,484 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t kd, float* ab, + const fortran_int_t ldab, float* q, const fortran_int_t ldq, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSBEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &kd, ab, + &ldab, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, + iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t kd, double* ab, + const fortran_int_t ldab, double* q, const fortran_int_t ldq, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSBEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &kd, ab, + &ldab, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, + iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + std::complex* ab, const fortran_int_t ldab, + std::complex* q, const fortran_int_t ldq, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CHBEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &kd, ab, + &ldab, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, + rwork, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + std::complex* ab, const fortran_int_t ldab, + std::complex* q, const fortran_int_t ldq, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZHBEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &kd, ab, + &ldab, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, + rwork, iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbevx. +// +template< typename Value, typename Enable = void > +struct hbevx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbevx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hbevx( jobz, range, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(q), + bindings::stride_major(q), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbevx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hbevx( jobz, range, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(q), + bindings::stride_major(q), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbevx( const char jobz, const char range, MatrixAB& ab, MatrixQ& q, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, Workspace work ) { + return hbevx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, q, vl, vu, il, iu, + abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for hbevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +hbevx( const char jobz, const char range, MatrixAB& ab, MatrixQ& q, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail ) { + return hbevx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, q, vl, vu, il, iu, + abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hbgv.hpp b/sdk/boost/numeric/bindings/lapack/driver/hbgv.hpp new file mode 100644 index 0000000..f966778 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hbgv.hpp @@ -0,0 +1,397 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbgv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgv( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t ka, const fortran_int_t kb, float* ab, + const fortran_int_t ldab, float* bb, const fortran_int_t ldbb, + float* w, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSBGV( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgv( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t ka, const fortran_int_t kb, double* ab, + const fortran_int_t ldab, double* bb, const fortran_int_t ldbb, + double* w, double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSBGV( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgv( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + std::complex* bb, const fortran_int_t ldbb, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHBGV( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgv( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + std::complex* bb, const fortran_int_t ldbb, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHBGV( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbgv. +// +template< typename Value, typename Enable = void > +struct hbgv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbgv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbgv( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, ab, bb, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbgv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbgv( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, ab, bb, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 3*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbgv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbgv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbgv( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z, Workspace work ) { + return hbgv_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, work ); +} + +// +// Overloaded function for hbgv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hbgv( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z ) { + return hbgv_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hbgvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/hbgvd.hpp new file mode 100644 index 0000000..8332f56 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hbgvd.hpp @@ -0,0 +1,505 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbgvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + float* ab, const fortran_int_t ldab, float* bb, + const fortran_int_t ldbb, float* w, float* z, const fortran_int_t ldz, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSBGVD( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + double* ab, const fortran_int_t ldab, double* bb, + const fortran_int_t ldbb, double* w, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSBGVD( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + std::complex* bb, const fortran_int_t ldbb, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, float* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHBGVD( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &lwork, rwork, &lrwork, iwork, + &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + std::complex* bb, const fortran_int_t ldbb, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, double* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHBGVD( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &lwork, rwork, &lrwork, iwork, + &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbgvd. +// +template< typename Value, typename Enable = void > +struct hbgvd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbgvd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbgvd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ab) ) ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::hbgvd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 3*n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbgvd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hbgvd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ab) ) ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::hbgvd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbgvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbgvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbgvd( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z, Workspace work ) { + return hbgvd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, work ); +} + +// +// Overloaded function for hbgvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hbgvd( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z ) { + return hbgvd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hbgvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hbgvx.hpp new file mode 100644 index 0000000..d8a3f78 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hbgvx.hpp @@ -0,0 +1,514 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HBGVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hbgvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + float* ab, const fortran_int_t ldab, float* bb, + const fortran_int_t ldbb, float* q, const fortran_int_t ldq, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSBGVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &ka, &kb, + ab, &ldab, bb, &ldbb, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, + z, &ldz, work, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + double* ab, const fortran_int_t ldab, double* bb, + const fortran_int_t ldbb, double* q, const fortran_int_t ldq, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSBGVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &ka, &kb, + ab, &ldab, bb, &ldbb, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, + z, &ldz, work, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + std::complex* bb, const fortran_int_t ldbb, + std::complex* q, const fortran_int_t ldq, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CHBGVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &ka, &kb, + ab, &ldab, bb, &ldbb, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, + z, &ldz, work, rwork, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hbgvx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + std::complex* ab, const fortran_int_t ldab, + std::complex* bb, const fortran_int_t ldbb, + std::complex* q, const fortran_int_t ldq, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZHBGVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &ka, &kb, + ab, &ldab, bb, &ldbb, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, + z, &ldz, work, rwork, iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hbgvx. +// +template< typename Value, typename Enable = void > +struct hbgvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hbgvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hbgvx( jobz, range, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(q), + bindings::stride_major(q), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w, + z, ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hbgvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hbgvx( jobz, range, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(q), + bindings::stride_major(q), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w, + z, ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hbgvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hbgvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hbgvx( const char jobz, const char range, MatrixAB& ab, MatrixBB& bb, + MatrixQ& q, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return hbgvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, bb, q, vl, vu, il, + iu, abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for hbgvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +hbgvx( const char jobz, const char range, MatrixAB& ab, MatrixBB& bb, + MatrixQ& q, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return hbgvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, bb, q, vl, vu, il, + iu, abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/heev.hpp b/sdk/boost/numeric/bindings/lapack/driver/heev.hpp new file mode 100644 index 0000000..93fbf87 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/heev.hpp @@ -0,0 +1,351 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for heev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heev( const char jobz, const UpLo, const fortran_int_t n, + float* a, const fortran_int_t lda, float* w, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYEV( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heev( const char jobz, const UpLo, const fortran_int_t n, + double* a, const fortran_int_t lda, double* w, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYEV( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heev( const char jobz, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, float* w, + std::complex* work, const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHEEV( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heev( const char jobz, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, double* w, + std::complex* work, const fortran_int_t lwork, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHEEV( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to heev. +// +template< typename Value, typename Enable = void > +struct heev_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct heev_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::heev( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( jobz, a, w, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::heev( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, a, w, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-1); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct heev_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::heev( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::heev( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), &opt_size_work, -1, + bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*n-1); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-2); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the heev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for heev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +heev( const char jobz, MatrixA& a, VectorW& w, Workspace work ) { + return heev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, work ); +} + +// +// Overloaded function for heev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +heev( const char jobz, MatrixA& a, VectorW& w ) { + return heev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/heevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/heevd.hpp new file mode 100644 index 0000000..18a104e --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/heevd.hpp @@ -0,0 +1,428 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for heevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevd( const char jobz, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, float* w, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSYEVD( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevd( const char jobz, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, double* w, + double* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSYEVD( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevd( const char jobz, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, float* w, std::complex* work, + const fortran_int_t lwork, float* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHEEVD( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevd( const char jobz, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, double* w, std::complex* work, + const fortran_int_t lwork, double* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHEEVD( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to heevd. +// +template< typename Value, typename Enable = void > +struct heevd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct heevd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::heevd( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(a) ) ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::heevd( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), &opt_size_work, -1, &opt_size_iwork, + -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n + 1; + else + return 1 + 6*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct heevd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename WORK, + typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::heevd( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(a) ) ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::heevd( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), &opt_size_work, -1, &opt_size_rwork, + -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n+1; + else + return 2*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the heevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for heevd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +heevd( const char jobz, MatrixA& a, VectorW& w, Workspace work ) { + return heevd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, work ); +} + +// +// Overloaded function for heevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +heevd( const char jobz, MatrixA& a, VectorW& w ) { + return heevd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/heevr.hpp b/sdk/boost/numeric/bindings/lapack/driver/heevr.hpp new file mode 100644 index 0000000..f10c449 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/heevr.hpp @@ -0,0 +1,489 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for heevr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevr( const char jobz, const char range, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, fortran_int_t* isuppz, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSYEVR( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, isuppz, work, &lwork, + iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevr( const char jobz, const char range, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, fortran_int_t* isuppz, + double* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSYEVR( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, isuppz, work, &lwork, + iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevr( const char jobz, const char range, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, const float vl, const float vu, + const fortran_int_t il, const fortran_int_t iu, const float abstol, + fortran_int_t& m, float* w, std::complex* z, + const fortran_int_t ldz, fortran_int_t* isuppz, + std::complex* work, const fortran_int_t lwork, float* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHEEVR( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, isuppz, work, &lwork, + rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevr( const char jobz, const char range, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, const double vl, const double vu, + const fortran_int_t il, const fortran_int_t iu, const double abstol, + fortran_int_t& m, double* w, std::complex* z, + const fortran_int_t ldz, fortran_int_t* isuppz, + std::complex* work, const fortran_int_t lwork, double* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHEEVR( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, isuppz, work, &lwork, + rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to heevr. +// +template< typename Value, typename Enable = void > +struct heevr_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct heevr_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::heevr( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(isuppz), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::heevr( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(isuppz), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 26*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct heevr_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ, typename WORK, typename RWORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::heevr( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(isuppz), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::heevr( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(isuppz), &opt_size_work, -1, + &opt_size_rwork, -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 24*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the heevr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for heevr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +heevr( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, Workspace work ) { + return heevr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, isuppz, work ); +} + +// +// Overloaded function for heevr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > +inline typename boost::disable_if< detail::is_workspace< VectorISUPPZ >, + std::ptrdiff_t >::type +heevr( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz ) { + return heevr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, isuppz, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/heevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/heevx.hpp new file mode 100644 index 0000000..e0efc62 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/heevx.hpp @@ -0,0 +1,485 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for heevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSYEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, &lwork, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSYEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, &lwork, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, const float vl, const float vu, + const fortran_int_t il, const fortran_int_t iu, const float abstol, + fortran_int_t& m, float* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CHEEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, &lwork, rwork, + iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t heevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, std::complex* a, + const fortran_int_t lda, const double vl, const double vu, + const fortran_int_t il, const fortran_int_t iu, const double abstol, + fortran_int_t& m, double* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZHEEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, &lwork, rwork, + iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to heevx. +// +template< typename Value, typename Enable = void > +struct heevx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct heevx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::heevx( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::heevx( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, bindings::begin_value(tmp_iwork), + bindings::begin_value(ifail) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct heevx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename RWORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::heevx( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, + workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::heevx( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_iwork), + bindings::begin_value(ifail) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, + workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the heevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for heevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +heevx( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, Workspace work ) { + return heevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, ifail, work ); +} + +// +// Overloaded function for heevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +heevx( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail ) { + return heevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hegv.hpp b/sdk/boost/numeric/bindings/lapack/driver/hegv.hpp new file mode 100644 index 0000000..572c556 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hegv.hpp @@ -0,0 +1,393 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hegv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* a, const fortran_int_t lda, + float* b, const fortran_int_t ldb, float* w, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* w, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, float* w, std::complex* work, + const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHEGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, double* w, std::complex* work, + const fortran_int_t lwork, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHEGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hegv. +// +template< typename Value, typename Enable = void > +struct hegv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hegv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hegv( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::hegv( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 3*n-1 ); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hegv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hegv( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::hegv( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), &opt_size_work, -1, + bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n-1 ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 3*n-2 ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hegv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hegv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hegv( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w, Workspace work ) { + return hegv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, work ); +} + +// +// Overloaded function for hegv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +hegv( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w ) { + return hegv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hegvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/hegvd.hpp new file mode 100644 index 0000000..d79dcf8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hegvd.hpp @@ -0,0 +1,468 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hegvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* a, const fortran_int_t lda, + float* b, const fortran_int_t ldb, float* w, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSYGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* w, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSYGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, float* w, std::complex* work, + const fortran_int_t lwork, float* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHEGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb, double* w, std::complex* work, + const fortran_int_t lwork, double* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHEGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hegvd. +// +template< typename Value, typename Enable = void > +struct hegvd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hegvd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hegvd( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(a) ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::hegvd( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), &opt_size_work, -1, &opt_size_iwork, + -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n + 1; + else + return 1 + 6*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hegvd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hegvd( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(a) ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::hegvd( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), &opt_size_work, -1, &opt_size_rwork, + -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n+1; + else + return 2*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hegvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hegvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hegvd( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w, Workspace work ) { + return hegvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, work ); +} + +// +// Overloaded function for hegvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +hegvd( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w ) { + return hegvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hegvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hegvx.hpp new file mode 100644 index 0000000..96211d2 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hegvx.hpp @@ -0,0 +1,522 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HEGVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hegvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSYGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + a, &lda, b, &ldb, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, + work, &lwork, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSYGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + a, &lda, b, &ldb, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, + work, &lwork, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, float* rwork, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CHEGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + a, &lda, b, &ldb, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, + work, &lwork, rwork, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hegvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, + std::complex* a, const fortran_int_t lda, + std::complex* b, const fortran_int_t ldb, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, double* rwork, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZHEGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + a, &lda, b, &ldb, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, + work, &lwork, rwork, iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hegvx. +// +template< typename Value, typename Enable = void > +struct hegvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hegvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hegvx( itype, jobz, range, uplo(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::hegvx( itype, jobz, range, uplo(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + bindings::begin_value(tmp_iwork), + bindings::begin_value(ifail) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,8*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hegvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hegvx( itype, jobz, range, uplo(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::hegvx( itype, jobz, range, uplo(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + bindings::begin_value(tmp_rwork), + bindings::begin_value(tmp_iwork), + bindings::begin_value(ifail) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hegvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hegvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hegvx( const fortran_int_t itype, const char jobz, const char range, + MatrixA& a, MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return hegvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il, + iu, abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for hegvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +hegvx( const fortran_int_t itype, const char jobz, const char range, + MatrixA& a, MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return hegvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il, + iu, abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hesv.hpp b/sdk/boost/numeric/bindings/lapack/driver/hesv.hpp new file mode 100644 index 0000000..24cef91 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hesv.hpp @@ -0,0 +1,362 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HESV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HESV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hesv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, + fortran_int_t* ipiv, float* b, const fortran_int_t ldb, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + fortran_int_t* ipiv, double* b, const fortran_int_t ldb, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CHESV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZHESV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hesv. +// +template< typename Value, typename Enable = void > +struct hesv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hesv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hesv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::hesv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hesv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::hesv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + detail::hesv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hesv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hesv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, Workspace work ) { + return hesv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b, work ); +} + +// +// Overloaded function for hesv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB > +inline typename boost::disable_if< detail::is_workspace< MatrixB >, + std::ptrdiff_t >::type +hesv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) { + return hesv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hesvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hesvx.hpp new file mode 100644 index 0000000..97b5a04 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hesvx.hpp @@ -0,0 +1,516 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HESVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HESVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hesvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const float* a, + const fortran_int_t lda, float* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float& rcond, float* ferr, + float* berr, float* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSYSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const double* a, + const fortran_int_t lda, double* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double& rcond, double* ferr, + double* berr, double* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSYSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float& rcond, float* ferr, float* berr, + std::complex* work, const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHESVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hesvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + std::complex* work, const fortran_int_t lwork, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHESVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hesvx. +// +template< typename Value, typename Enable = void > +struct hesvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hesvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::hesvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::hesvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + &opt_size_work, -1, bindings::begin_value(tmp_iwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 3*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hesvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::hesvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::hesvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hesvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hesvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hesvx( const char fact, const MatrixA& a, MatrixAF& af, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return hesvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, ipiv, b, x, rcond, ferr, + berr, work ); +} + +// +// Overloaded function for hesvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +hesvx( const char fact, const MatrixA& a, MatrixAF& af, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr ) { + return hesvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, ipiv, b, x, rcond, ferr, + berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpev.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpev.hpp new file mode 100644 index 0000000..711cf16 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpev.hpp @@ -0,0 +1,340 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpev( const char jobz, const UpLo, const fortran_int_t n, + float* ap, float* w, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSPEV( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpev( const char jobz, const UpLo, const fortran_int_t n, + double* ap, double* w, double* z, const fortran_int_t ldz, + double* work ) { + fortran_int_t info(0); + LAPACK_DSPEV( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpev( const char jobz, const UpLo, const fortran_int_t n, + std::complex* ap, float* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHPEV( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpev( const char jobz, const UpLo, const fortran_int_t n, + std::complex* ap, double* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHPEV( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpev. +// +template< typename Value, typename Enable = void > +struct hpev_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpev_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpev( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( jobz, ap, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( jobz, ap, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpev_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpev( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( jobz, ap, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*n-1); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-2); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpev( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z, + Workspace work ) { + return hpev_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, work ); +} + +// +// Overloaded function for hpev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hpev( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z ) { + return hpev_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpevd.hpp new file mode 100644 index 0000000..f2d2f9d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpevd.hpp @@ -0,0 +1,438 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevd( const char jobz, const UpLo, + const fortran_int_t n, float* ap, float* w, float* z, + const fortran_int_t ldz, float* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSPEVD( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevd( const char jobz, const UpLo, + const fortran_int_t n, double* ap, double* w, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSPEVD( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevd( const char jobz, const UpLo, + const fortran_int_t n, std::complex* ap, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, float* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHPEVD( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevd( const char jobz, const UpLo, + const fortran_int_t n, std::complex* ap, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, const fortran_int_t lwork, double* rwork, + const fortran_int_t lrwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHPEVD( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpevd. +// +template< typename Value, typename Enable = void > +struct hpevd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpevd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpevd( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ap) ) ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::hpevd( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n; + else + return 1 + 6*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpevd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpevd( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ap) ) ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::hpevd( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_rwork, -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_rwork, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 2*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpevd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpevd( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z, + Workspace work ) { + return hpevd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, work ); +} + +// +// Overloaded function for hpevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hpevd( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z ) { + return hpevd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpevx.hpp new file mode 100644 index 0000000..ae1cfdf --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpevx.hpp @@ -0,0 +1,436 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, float* ap, const float vl, const float vu, + const fortran_int_t il, const fortran_int_t iu, const float abstol, + fortran_int_t& m, float* w, float* z, const fortran_int_t ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSPEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, ap, &vl, + &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, ifail, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, double* ap, const double vl, const double vu, + const fortran_int_t il, const fortran_int_t iu, const double abstol, + fortran_int_t& m, double* w, double* z, const fortran_int_t ldz, + double* work, fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSPEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, ap, &vl, + &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, ifail, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, std::complex* ap, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CHPEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, ap, &vl, + &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, rwork, iwork, ifail, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, std::complex* ap, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZHPEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, ap, &vl, + &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, rwork, iwork, ifail, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpevx. +// +template< typename Value, typename Enable = void > +struct hpevx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpevx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hpevx( jobz, range, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpevx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename RWORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hpevx( jobz, range, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpevx( const char jobz, const char range, MatrixAP& ap, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, Workspace work ) { + return hpevx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, range, ap, vl, vu, il, iu, + abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for hpevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +hpevx( const char jobz, const char range, MatrixAP& ap, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail ) { + return hpevx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, range, ap, vl, vu, il, iu, + abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpgv.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpgv.hpp new file mode 100644 index 0000000..8602419 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpgv.hpp @@ -0,0 +1,369 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpgv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* ap, float* bp, float* w, + float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSPGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, w, + z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* ap, double* bp, double* w, + double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSPGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, w, + z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* ap, + std::complex* bp, float* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHPGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, w, + z, &ldz, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* ap, + std::complex* bp, double* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHPGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, w, + z, &ldz, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpgv. +// +template< typename Value, typename Enable = void > +struct hpgv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpgv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpgv( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpgv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpgv( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,2*n-1); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-2); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpgv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpgv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpgv( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) { + return hpgv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, work ); +} + +// +// Overloaded function for hpgv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hpgv( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z ) { + return hpgv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpgvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpgvd.hpp new file mode 100644 index 0000000..83f191b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpgvd.hpp @@ -0,0 +1,469 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpgvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* ap, float* bp, float* w, + float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSPGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* ap, double* bp, double* w, + double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSPGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* ap, + std::complex* bp, float* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, float* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_CHPGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, + w, z, &ldz, work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, std::complex* ap, + std::complex* bp, double* w, std::complex* z, + const fortran_int_t ldz, std::complex* work, + const fortran_int_t lwork, double* rwork, const fortran_int_t lrwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_ZHPGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, + w, z, &ldz, work, &lwork, rwork, &lrwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpgvd. +// +template< typename Value, typename Enable = void > +struct hpgvd_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpgvd_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpgvd( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ap) ) ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::hpgvd( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n; + else + return 1 + 6*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpgvd_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename WORK, typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, detail::workspace3< WORK, RWORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::hpgvd( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ap) ) ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + value_type opt_size_work; + real_type opt_size_rwork; + fortran_int_t opt_size_iwork; + detail::hpgvd( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + &opt_size_rwork, -1, &opt_size_iwork, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< real_type > tmp_rwork( + traits::detail::to_int( opt_size_rwork ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 2*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpgvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpgvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpgvd( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) { + return hpgvd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, work ); +} + +// +// Overloaded function for hpgvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +hpgvd( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z ) { + return hpgvd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpgvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpgvx.hpp new file mode 100644 index 0000000..9bb8bb1 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpgvx.hpp @@ -0,0 +1,462 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPGVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpgvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, float* ap, + float* bp, const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSPGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + ap, bp, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, double* ap, + double* bp, const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSPGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + ap, bp, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, + std::complex* ap, std::complex* bp, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, float* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_CHPGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + ap, bp, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, rwork, + iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpgvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, + std::complex* ap, std::complex* bp, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, + std::complex* z, const fortran_int_t ldz, + std::complex* work, double* rwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_ZHPGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + ap, bp, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, rwork, + iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpgvx. +// +template< typename Value, typename Enable = void > +struct hpgvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpgvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hpgvx( itype, jobz, range, uplo(), + bindings::size_column(ap), bindings::begin_value(ap), + bindings::begin_value(bp), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m, + w, z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m, + w, z, ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpgvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename RWORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace3< WORK, RWORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::hpgvx( itype, jobz, range, uplo(), + bindings::size_column(ap), bindings::begin_value(ap), + bindings::begin_value(bp), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m, + w, z, ifail, workspace( tmp_work, tmp_rwork, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m, + w, z, ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpgvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpgvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpgvx( const fortran_int_t itype, const char jobz, const char range, + MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return hpgvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu, + il, iu, abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for hpgvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +hpgvx( const fortran_int_t itype, const char jobz, const char range, + MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return hpgvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu, + il, iu, abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpsv.hpp new file mode 100644 index 0000000..6815437 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpsv.hpp @@ -0,0 +1,176 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, float* ap, fortran_int_t* ipiv, float* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* ap, fortran_int_t* ipiv, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* ap, + fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CHPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* ap, + fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZHPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpsv. +// +template< typename Value > +struct hpsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::hpsv( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpsv. Its overload differs for +// +template< typename MatrixAP, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t hpsv( MatrixAP& ap, VectorIPIV& ipiv, MatrixB& b ) { + return hpsv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/hpsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/hpsvx.hpp new file mode 100644 index 0000000..f6f5108 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/hpsvx.hpp @@ -0,0 +1,457 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_HPSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for hpsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const float* ap, + float* afp, fortran_int_t* ipiv, const float* b, + const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float& rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const double* ap, + double* afp, fortran_int_t* ipiv, const double* b, + const fortran_int_t ldb, double* x, const fortran_int_t ldx, + double& rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, std::complex* afp, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float& rcond, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CHPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t hpsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, std::complex* afp, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZHPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to hpsvx. +// +template< typename Value, typename Enable = void > +struct hpsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct hpsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::hpsvx( fact, uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct hpsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::hpsvx( fact, uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the hpsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for hpsvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +hpsvx( const char fact, const MatrixAP& ap, MatrixAFP& afp, + VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return hpsvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( fact, ap, afp, ipiv, b, x, rcond, + ferr, berr, work ); +} + +// +// Overloaded function for hpsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +hpsvx( const char fact, const MatrixAP& ap, MatrixAFP& afp, + VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) { + return hpsvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( fact, ap, afp, ipiv, b, x, rcond, + ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/iter_gesv.hpp b/sdk/boost/numeric/bindings/lapack/driver/iter_gesv.hpp new file mode 100644 index 0000000..d82b9c4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/iter_gesv.hpp @@ -0,0 +1,390 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_ITER_GESV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_ITER_GESV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for iter_gesv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t iter_gesv( const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + fortran_int_t* ipiv, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double* work, float* swork, + fortran_int_t& iter ) { + fortran_int_t info(0); + LAPACK_DSGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, x, &ldx, work, swork, + &iter, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t iter_gesv( const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, + std::complex* work, std::complex* swork, double* rwork, + fortran_int_t& iter ) { + fortran_int_t info(0); + LAPACK_ZCGESV( &n, &nrhs, a, &lda, ipiv, b, &ldb, x, &ldx, work, swork, + rwork, &iter, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to iter_gesv. +// +template< typename Value, typename Enable = void > +struct iter_gesv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct iter_gesv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename WORK, typename SWORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, fortran_int_t& iter, + detail::workspace2< WORK, SWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_swork( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::iter_gesv( bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(real_type())), iter ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, fortran_int_t& iter, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_swork( min_size_swork( + bindings::size_column(a), bindings::size_column(b) ) ); + return invoke( a, ipiv, b, x, iter, workspace( tmp_work, tmp_swork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, fortran_int_t& iter, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( a, ipiv, b, x, iter, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*nrhs; + } + + // + // Static member function that returns the minimum size of + // workspace-array swork. + // + static std::ptrdiff_t min_size_swork( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*(n+nrhs); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct iter_gesv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename WORK, typename SWORK, typename RWORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, fortran_int_t& iter, + detail::workspace3< WORK, SWORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::size(ipiv) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_swork( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::iter_gesv( bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), iter ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, fortran_int_t& iter, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_column(b) ) ); + bindings::detail::array< value_type > tmp_swork( min_size_swork( + bindings::size_column(a), bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, ipiv, b, x, iter, workspace( tmp_work, tmp_swork, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, fortran_int_t& iter, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( a, ipiv, b, x, iter, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*nrhs; + } + + // + // Static member function that returns the minimum size of + // workspace-array swork. + // + static std::ptrdiff_t min_size_swork( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*(n+nrhs); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the iter_gesv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for iter_gesv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +iter_gesv( MatrixA& a, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, Workspace work ) { + return iter_gesv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b, x, iter, work ); +} + +// +// Overloaded function for iter_gesv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename MatrixX > +inline typename boost::disable_if< detail::is_workspace< MatrixX >, + std::ptrdiff_t >::type +iter_gesv( MatrixA& a, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + fortran_int_t& iter ) { + return iter_gesv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b, x, iter, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/iter_posv.hpp b/sdk/boost/numeric/bindings/lapack/driver/iter_posv.hpp new file mode 100644 index 0000000..f8c85f3 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/iter_posv.hpp @@ -0,0 +1,383 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_ITER_POSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_ITER_POSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for iter_posv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t iter_posv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + const double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double* work, float* swork, + fortran_int_t& iter ) { + fortran_int_t info(0); + LAPACK_DSPOSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + x, &ldx, work, swork, &iter, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t iter_posv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, std::complex* work, + std::complex* swork, double* rwork, fortran_int_t& iter ) { + fortran_int_t info(0); + LAPACK_ZCPOSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + x, &ldx, work, swork, rwork, &iter, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to iter_posv. +// +template< typename Value, typename Enable = void > +struct iter_posv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct iter_posv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename WORK, typename SWORK > + static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, detail::workspace2< WORK, SWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_swork( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::iter_posv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(real_type())), iter ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_swork( min_size_swork( + bindings::size_column(a), bindings::size_column(b) ) ); + return invoke( a, b, x, iter, workspace( tmp_work, tmp_swork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, b, x, iter, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*nrhs; + } + + // + // Static member function that returns the minimum size of + // workspace-array swork. + // + static std::ptrdiff_t min_size_swork( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*(n+nrhs); + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct iter_posv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename MatrixX, + typename WORK, typename SWORK, typename RWORK > + static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, detail::workspace3< WORK, SWORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_swork( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a), + bindings::size_column(b) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::iter_posv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())), iter ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a), bindings::size_column(b) ) ); + bindings::detail::array< value_type > tmp_swork( min_size_swork( + bindings::size_column(a), bindings::size_column(b) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( a, b, x, iter, workspace( tmp_work, tmp_swork, + tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename MatrixX > + static std::ptrdiff_t invoke( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( a, b, x, iter, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*nrhs; + } + + // + // Static member function that returns the minimum size of + // workspace-array swork. + // + static std::ptrdiff_t min_size_swork( const std::ptrdiff_t n, + const std::ptrdiff_t nrhs ) { + return n*(n+nrhs); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the iter_posv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for iter_posv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename MatrixX, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +iter_posv( MatrixA& a, const MatrixB& b, MatrixX& x, fortran_int_t& iter, + Workspace work ) { + return iter_posv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, x, iter, work ); +} + +// +// Overloaded function for iter_posv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename MatrixX > +inline typename boost::disable_if< detail::is_workspace< MatrixX >, + std::ptrdiff_t >::type +iter_posv( MatrixA& a, const MatrixB& b, MatrixX& x, + fortran_int_t& iter ) { + return iter_posv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b, x, iter, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/pbsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/pbsv.hpp new file mode 100644 index 0000000..dd42a27 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/pbsv.hpp @@ -0,0 +1,182 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PBSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PBSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsv( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, float* ab, + const fortran_int_t ldab, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPBSV( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsv( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, double* ab, + const fortran_int_t ldab, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPBSV( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsv( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, + std::complex* ab, const fortran_int_t ldab, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPBSV( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, b, + &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsv( const UpLo, const fortran_int_t n, + const fortran_int_t kd, const fortran_int_t nrhs, + std::complex* ab, const fortran_int_t ldab, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPBSV( &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, &ldab, b, + &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbsv. +// +template< typename Value > +struct pbsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixB > + static std::ptrdiff_t invoke( MatrixAB& ab, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + return detail::pbsv( uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbsv. Its overload differs for +// +template< typename MatrixAB, typename MatrixB > +inline std::ptrdiff_t pbsv( MatrixAB& ab, MatrixB& b ) { + return pbsv_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( ab, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/pbsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/pbsvx.hpp new file mode 100644 index 0000000..bcdd5d8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/pbsvx.hpp @@ -0,0 +1,508 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PBSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PBSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for pbsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, float* ab, const fortran_int_t ldab, + float* afb, const fortran_int_t ldafb, char& equed, float* s, + float* b, const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float& rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPBSVX( &fact, &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, + &ldab, afb, &ldafb, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, double* ab, const fortran_int_t ldab, + double* afb, const fortran_int_t ldafb, char& equed, double* s, + double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPBSVX( &fact, &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, + &ldab, afb, &ldafb, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, std::complex* ab, + const fortran_int_t ldab, std::complex* afb, + const fortran_int_t ldafb, char& equed, float* s, + std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPBSVX( &fact, &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, + &ldab, afb, &ldafb, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t pbsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t kd, + const fortran_int_t nrhs, std::complex* ab, + const fortran_int_t ldab, std::complex* afb, + const fortran_int_t ldafb, char& equed, double* s, + std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double& rcond, + double* ferr, double* berr, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPBSVX( &fact, &lapack_option< UpLo >::value, &n, &kd, &nrhs, ab, + &ldab, afb, &ldafb, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, + berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to pbsvx. +// +template< typename Value, typename Enable = void > +struct pbsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct pbsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( equed == 'N' || equed == 'Y' ); + BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' || + fact == 'E' ); + return detail::pbsvx( fact, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(afb), bindings::stride_major(afb), + equed, bindings::begin_value(s), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), rcond, bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct pbsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(afb) == 1 || + bindings::stride_minor(afb) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(afb) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( equed == 'N' || equed == 'Y' ); + BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' || + fact == 'E' ); + return detail::pbsvx( fact, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::size_column(b), + bindings::begin_value(ab), bindings::stride_major(ab), + bindings::begin_value(afb), bindings::stride_major(afb), + equed, bindings::begin_value(s), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), rcond, bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ab) ) ); + return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAB& ab, + MatrixAFB& afb, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( fact, ab, afb, equed, s, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the pbsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for pbsvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +pbsvx( const char fact, MatrixAB& ab, MatrixAFB& afb, char& equed, + VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return pbsvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( fact, ab, afb, equed, s, b, x, rcond, + ferr, berr, work ); +} + +// +// Overloaded function for pbsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixAFB, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +pbsvx( const char fact, MatrixAB& ab, MatrixAFB& afb, char& equed, + VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr ) { + return pbsvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( fact, ab, afb, equed, s, b, x, rcond, + ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/posv.hpp b/sdk/boost/numeric/bindings/lapack/driver/posv.hpp new file mode 100644 index 0000000..6f5d964 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/posv.hpp @@ -0,0 +1,246 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_POSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_POSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for posv is selected by defining a pre-processor +// variable, which can be one of +// * for ATLAS's CLAPACK, define BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// * netlib-compatible LAPACK is the default +// +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +#include +#include +#else +#include +#include +#endif + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +#if defined BOOST_NUMERIC_BINDINGS_LAPACK_CLAPACK +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const int n, const int nrhs, + float* a, const int lda, float* b, const int ldb ) { + return clapack_sposv( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const int n, const int nrhs, + double* a, const int lda, double* b, const int ldb ) { + return clapack_dposv( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const int n, const int nrhs, + std::complex* a, const int lda, std::complex* b, + const int ldb ) { + return clapack_cposv( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +// +// Overloaded function for dispatching to +// * ATLAS's CLAPACK backend, and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const int n, const int nrhs, + std::complex* a, const int lda, std::complex* b, + const int ldb ) { + return clapack_zposv( clapack_option< Order >::value, clapack_option< + UpLo >::value, n, nrhs, a, lda, b, ldb ); +} + +#else +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, float* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_SPOSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_DPOSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_CPOSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename Order, typename UpLo > +inline std::ptrdiff_t posv( Order, const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, std::complex* b, + const fortran_int_t ldb ) { + BOOST_STATIC_ASSERT( (is_same::value) ); + fortran_int_t info(0); + LAPACK_ZPOSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, b, &ldb, + &info ); + return info; +} + +#endif +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to posv. +// +template< typename Value > +struct posv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::data_order< MatrixA >::type order; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::posv( order(), uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the posv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for posv. Its overload differs for +// +template< typename MatrixA, typename MatrixB > +inline std::ptrdiff_t posv( MatrixA& a, MatrixB& b ) { + return posv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/posvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/posvx.hpp new file mode 100644 index 0000000..c2316c0 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/posvx.hpp @@ -0,0 +1,495 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_POSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_POSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for posvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t posvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, float* a, + const fortran_int_t lda, float* af, const fortran_int_t ldaf, + char& equed, float* s, float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float& rcond, float* ferr, float* berr, + float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPOSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t posvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, double* a, + const fortran_int_t lda, double* af, const fortran_int_t ldaf, + char& equed, double* s, double* b, const fortran_int_t ldb, double* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + double* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPOSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t posvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, char& equed, + float* s, std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPOSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t posvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, char& equed, + double* s, std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double& rcond, + double* ferr, double* berr, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPOSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to posvx. +// +template< typename Value, typename Enable = void > +struct posvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct posvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( equed == 'N' || equed == 'Y' ); + BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' || + fact == 'E' ); + return detail::posvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), equed, bindings::begin_value(s), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct posvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, detail::workspace2< WORK, + RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( equed == 'N' || equed == 'Y' ); + BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' || + fact == 'E' ); + return detail::posvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), equed, bindings::begin_value(s), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixA& a, MatrixAF& af, + char& equed, VectorS& s, MatrixB& b, MatrixX& x, real_type& rcond, + VectorFERR& ferr, VectorBERR& berr, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + return invoke( fact, a, af, equed, s, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the posvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for posvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +posvx( const char fact, MatrixA& a, MatrixAF& af, char& equed, + VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return posvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, equed, s, b, x, rcond, + ferr, berr, work ); +} + +// +// Overloaded function for posvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +posvx( const char fact, MatrixA& a, MatrixAF& af, char& equed, + VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr ) { + return posvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, equed, s, b, x, rcond, + ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ppsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/ppsv.hpp new file mode 100644 index 0000000..94f84ce --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ppsv.hpp @@ -0,0 +1,172 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PPSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PPSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ppsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, float* ap, float* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* ap, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* ap, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* ap, + std::complex* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, b, &ldb, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ppsv. +// +template< typename Value > +struct ppsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixB > + static std::ptrdiff_t invoke( MatrixAP& ap, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::ppsv( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ppsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ppsv. Its overload differs for +// +template< typename MatrixAP, typename MatrixB > +inline std::ptrdiff_t ppsv( MatrixAP& ap, MatrixB& b ) { + return ppsv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ppsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/ppsvx.hpp new file mode 100644 index 0000000..4475970 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ppsvx.hpp @@ -0,0 +1,474 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PPSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PPSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ppsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, float* ap, + float* afp, char& equed, float* s, float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float& rcond, float* ferr, + float* berr, float* work, fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SPPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, double* ap, + double* afp, char& equed, double* s, double* b, + const fortran_int_t ldb, double* x, const fortran_int_t ldx, + double& rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DPPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* ap, std::complex* afp, char& equed, + float* s, std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t ppsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + std::complex* ap, std::complex* afp, char& equed, + double* s, std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double& rcond, + double* ferr, double* berr, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + &equed, s, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ppsvx. +// +template< typename Value, typename Enable = void > +struct ppsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ppsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, MatrixAP& ap, + VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorS >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorAFP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( equed == 'N' || equed == 'Y' ); + BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' || + fact == 'E' ); + return detail::ppsvx( fact, uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), equed, bindings::begin_value(s), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAP& ap, + VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( fact, ap, afp, equed, s, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAP& ap, + VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( fact, ap, afp, equed, s, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ppsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, MatrixAP& ap, + VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorS >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorAFP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorS >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( equed == 'N' || equed == 'Y' ); + BOOST_ASSERT( fact == 'F' || fact == 'Y' || fact == 'N' || + fact == 'E' ); + return detail::ppsvx( fact, uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), equed, bindings::begin_value(s), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAP& ap, + VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( fact, ap, afp, equed, s, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, MatrixAP& ap, + VectorAFP& afp, char& equed, VectorS& s, MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( fact, ap, afp, equed, s, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ppsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ppsvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ppsvx( const char fact, MatrixAP& ap, VectorAFP& afp, char& equed, + VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return ppsvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( fact, ap, afp, equed, s, b, x, rcond, + ferr, berr, work ); +} + +// +// Overloaded function for ppsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorAFP, typename VectorS, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +ppsvx( const char fact, MatrixAP& ap, VectorAFP& afp, char& equed, + VectorS& s, MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr ) { + return ppsvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( fact, ap, afp, equed, s, b, x, rcond, + ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ptsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/ptsv.hpp new file mode 100644 index 0000000..fc48a73 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ptsv.hpp @@ -0,0 +1,216 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PTSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PTSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ptsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ptsv( const fortran_int_t n, const fortran_int_t nrhs, + float* d, float* e, float* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SPTSV( &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ptsv( const fortran_int_t n, const fortran_int_t nrhs, + double* d, double* e, double* b, const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DPTSV( &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptsv( const fortran_int_t n, const fortran_int_t nrhs, + float* d, std::complex* e, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CPTSV( &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptsv( const fortran_int_t n, const fortran_int_t nrhs, + double* d, std::complex* e, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZPTSV( &n, &nrhs, d, e, b, &ldb, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ptsv. +// +template< typename Value, typename Enable = void > +struct ptsv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ptsv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( VectorD& d, VectorE& e, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + return detail::ptsv( bindings::size(d), bindings::size_column(b), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ptsv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixB > + static std::ptrdiff_t invoke( VectorD& d, VectorE& e, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + return detail::ptsv( bindings::size(d), bindings::size_column(b), + bindings::begin_value(d), bindings::begin_value(e), + bindings::begin_value(b), bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ptsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ptsv. Its overload differs for +// +template< typename VectorD, typename VectorE, typename MatrixB > +inline std::ptrdiff_t ptsv( VectorD& d, VectorE& e, MatrixB& b ) { + return ptsv_impl< typename bindings::value_type< + VectorE >::type >::invoke( d, e, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/ptsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/ptsvx.hpp new file mode 100644 index 0000000..8378d1f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/ptsvx.hpp @@ -0,0 +1,452 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PTSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_PTSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for ptsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t ptsvx( const char fact, const fortran_int_t n, + const fortran_int_t nrhs, const float* d, const float* e, float* df, + float* ef, const float* b, const fortran_int_t ldb, float* x, + const fortran_int_t ldx, float& rcond, float* ferr, float* berr, + float* work ) { + fortran_int_t info(0); + LAPACK_SPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond, + ferr, berr, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t ptsvx( const char fact, const fortran_int_t n, + const fortran_int_t nrhs, const double* d, const double* e, + double* df, double* ef, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double& rcond, double* ferr, + double* berr, double* work ) { + fortran_int_t info(0); + LAPACK_DPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond, + ferr, berr, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptsvx( const char fact, const fortran_int_t n, + const fortran_int_t nrhs, const float* d, + const std::complex* e, float* df, std::complex* ef, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, float& rcond, + float* ferr, float* berr, std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond, + ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +inline std::ptrdiff_t ptsvx( const char fact, const fortran_int_t n, + const fortran_int_t nrhs, const double* d, + const std::complex* e, double* df, std::complex* ef, + const std::complex* b, const fortran_int_t ldb, + std::complex* x, const fortran_int_t ldx, double& rcond, + double* ferr, double* berr, std::complex* work, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZPTSVX( &fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond, + ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to ptsvx. +// +template< typename Value, typename Enable = void > +struct ptsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct ptsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK > + static std::ptrdiff_t invoke( const char fact, const VectorD& d, + const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorEF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorEF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size(d) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::ptsvx( fact, bindings::size(d), + bindings::size_column(b), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(df), + bindings::begin_value(ef), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), rcond, bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorD& d, + const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size(d) ) ); + return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr, + workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorD& d, + const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct ptsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename WORK, + typename RWORK > + static std::ptrdiff_t invoke( const char fact, const VectorD& d, + const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorDF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + VectorEF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorE >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorDF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorEF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(d) >= bindings::size(d) ); + BOOST_ASSERT( bindings::size(d) >= 0 ); + BOOST_ASSERT( bindings::size(e) >= bindings::size(d)-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size(d) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size(d) )); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size(d)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::ptsvx( fact, bindings::size(d), + bindings::size_column(b), bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(df), + bindings::begin_value(ef), bindings::begin_value(b), + bindings::stride_major(b), bindings::begin_value(x), + bindings::stride_major(x), rcond, bindings::begin_value(ferr), + bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorD& d, + const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size(d) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size(d) ) ); + return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const VectorD& d, + const VectorE& e, VectorDF& df, VectorEF& ef, const MatrixB& b, + MatrixX& x, real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( fact, d, e, df, ef, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the ptsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for ptsvx. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df, + VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< VectorE >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return ptsvx_impl< typename bindings::value_type< + VectorE >::type >::invoke( fact, d, e, df, ef, b, x, rcond, ferr, + berr, work ); +} + +// +// Overloaded function for ptsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorDF, + typename VectorEF, typename MatrixB, typename MatrixX, + typename VectorFERR, typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +ptsvx( const char fact, const VectorD& d, const VectorE& e, VectorDF& df, + VectorEF& ef, const MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< VectorE >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr ) { + return ptsvx_impl< typename bindings::value_type< + VectorE >::type >::invoke( fact, d, e, df, ef, b, x, rcond, ferr, + berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sbev.hpp b/sdk/boost/numeric/bindings/lapack/driver/sbev.hpp new file mode 100644 index 0000000..ca78d3d --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sbev.hpp @@ -0,0 +1,216 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbev( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t kd, float* ab, const fortran_int_t ldab, float* w, + float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSBEV( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, w, + z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbev( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t kd, double* ab, const fortran_int_t ldab, + double* w, double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSBEV( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, w, + z, &ldz, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbev. +// +template< typename Value > +struct sbev_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::sbev( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( jobz, ab, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, ab, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-2); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbev( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z, + Workspace work ) { + return sbev_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, work ); +} + +// +// Overloaded function for sbev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +sbev( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z ) { + return sbev_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sbevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/sbevd.hpp new file mode 100644 index 0000000..f0ad8b8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sbevd.hpp @@ -0,0 +1,259 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbevd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t kd, float* ab, + const fortran_int_t ldab, float* w, float* z, const fortran_int_t ldz, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSBEVD( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbevd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t kd, double* ab, + const fortran_int_t ldab, double* w, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSBEVD( &jobz, &lapack_option< UpLo >::value, &n, &kd, ab, &ldab, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbevd. +// +template< typename Value > +struct sbevd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::sbevd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ab) ) ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::sbevd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ab, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbevd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbevd( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z, + Workspace work ) { + return sbevd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, work ); +} + +// +// Overloaded function for sbevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +sbevd( const char jobz, MatrixAB& ab, VectorW& w, MatrixZ& z ) { + return sbevd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sbevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/sbevx.hpp new file mode 100644 index 0000000..38a7125 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sbevx.hpp @@ -0,0 +1,286 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t kd, float* ab, + const fortran_int_t ldab, float* q, const fortran_int_t ldq, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSBEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &kd, ab, + &ldab, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, + iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t kd, double* ab, + const fortran_int_t ldab, double* q, const fortran_int_t ldq, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSBEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &kd, ab, + &ldab, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, + iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbevx. +// +template< typename Value > +struct sbevx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ab) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(q) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ab)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::sbevx( jobz, range, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(q), + bindings::stride_major(q), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixQ& q, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, range, ab, q, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbevx( const char jobz, const char range, MatrixAB& ab, MatrixQ& q, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, Workspace work ) { + return sbevx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, q, vl, vu, il, iu, + abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for sbevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixQ, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +sbevx( const char jobz, const char range, MatrixAB& ab, MatrixQ& q, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail ) { + return sbevx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, q, vl, vu, il, iu, + abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sbgv.hpp b/sdk/boost/numeric/bindings/lapack/driver/sbgv.hpp new file mode 100644 index 0000000..930822c --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sbgv.hpp @@ -0,0 +1,236 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbgv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgv( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t ka, const fortran_int_t kb, float* ab, + const fortran_int_t ldab, float* bb, const fortran_int_t ldbb, + float* w, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSBGV( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgv( const char jobz, const UpLo, const fortran_int_t n, + const fortran_int_t ka, const fortran_int_t kb, double* ab, + const fortran_int_t ldab, double* bb, const fortran_int_t ldbb, + double* w, double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSBGV( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbgv. +// +template< typename Value > +struct sbgv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::sbgv( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, ab, bb, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbgv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbgv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbgv( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z, Workspace work ) { + return sbgv_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, work ); +} + +// +// Overloaded function for sbgv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +sbgv( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z ) { + return sbgv_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sbgvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/sbgvd.hpp new file mode 100644 index 0000000..37c3a87 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sbgvd.hpp @@ -0,0 +1,283 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbgvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgvd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + float* ab, const fortran_int_t ldab, float* bb, + const fortran_int_t ldbb, float* w, float* z, const fortran_int_t ldz, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSBGVD( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgvd( const char jobz, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + double* ab, const fortran_int_t ldab, double* bb, + const fortran_int_t ldbb, double* w, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSBGVD( &jobz, &lapack_option< UpLo >::value, &n, &ka, &kb, ab, + &ldab, bb, &ldbb, w, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbgvd. +// +template< typename Value > +struct sbgvd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::sbgvd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ab) ) ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAB& ab, MatrixBB& bb, + VectorW& w, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::sbgvd( jobz, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ab, bb, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 3*n; + else + return 1 + 5*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbgvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbgvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbgvd( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z, Workspace work ) { + return sbgvd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, work ); +} + +// +// Overloaded function for sbgvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +sbgvd( const char jobz, MatrixAB& ab, MatrixBB& bb, VectorW& w, + MatrixZ& z ) { + return sbgvd_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, ab, bb, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sbgvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/sbgvx.hpp new file mode 100644 index 0000000..c18eb3a --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sbgvx.hpp @@ -0,0 +1,302 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SBGVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sbgvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgvx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + float* ab, const fortran_int_t ldab, float* bb, + const fortran_int_t ldbb, float* q, const fortran_int_t ldq, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSBGVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &ka, &kb, + ab, &ldab, bb, &ldbb, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, + z, &ldz, work, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sbgvx( const char jobz, const char range, const UpLo, + const fortran_int_t n, const fortran_int_t ka, const fortran_int_t kb, + double* ab, const fortran_int_t ldab, double* bb, + const fortran_int_t ldbb, double* q, const fortran_int_t ldq, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSBGVX( &jobz, &range, &lapack_option< UpLo >::value, &n, &ka, &kb, + ab, &ldab, bb, &ldbb, q, &ldq, &vl, &vu, &il, &iu, &abstol, &m, w, + z, &ldz, work, iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sbgvx. +// +template< typename Value > +struct sbgvx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixQ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAB >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixQ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::bandwidth(ab, uplo()) >= 0 ); + BOOST_ASSERT( bindings::bandwidth(bb, uplo()) >= 0 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ab) )); + BOOST_ASSERT( bindings::size_column(ab) >= 0 ); + BOOST_ASSERT( bindings::size_minor(ab) == 1 || + bindings::stride_minor(ab) == 1 ); + BOOST_ASSERT( bindings::size_minor(bb) == 1 || + bindings::stride_minor(bb) == 1 ); + BOOST_ASSERT( bindings::size_minor(q) == 1 || + bindings::stride_minor(q) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(ab) >= bindings::bandwidth(ab, + uplo())+1 ); + BOOST_ASSERT( bindings::stride_major(bb) >= bindings::bandwidth(bb, + uplo())+1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::sbgvx( jobz, range, uplo(), bindings::size_column(ab), + bindings::bandwidth(ab, uplo()), bindings::bandwidth(bb, + uplo()), bindings::begin_value(ab), + bindings::stride_major(ab), bindings::begin_value(bb), + bindings::stride_major(bb), bindings::begin_value(q), + bindings::stride_major(q), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ab) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ab) ) ); + return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAB& ab, MatrixBB& bb, MatrixQ& q, const real_type vl, + const real_type vu, const fortran_int_t il, + const fortran_int_t iu, const real_type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAB >::type uplo; + return invoke( jobz, range, ab, bb, q, vl, vu, il, iu, abstol, m, w, + z, ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 7*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sbgvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sbgvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sbgvx( const char jobz, const char range, MatrixAB& ab, MatrixBB& bb, + MatrixQ& q, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return sbgvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, bb, q, vl, vu, il, + iu, abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for sbgvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAB, typename MatrixBB, typename MatrixQ, + typename VectorW, typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +sbgvx( const char jobz, const char range, MatrixAB& ab, MatrixBB& bb, + MatrixQ& q, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAB >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAB >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return sbgvx_impl< typename bindings::value_type< + MatrixAB >::type >::invoke( jobz, range, ab, bb, q, vl, vu, il, + iu, abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spev.hpp b/sdk/boost/numeric/bindings/lapack/driver/spev.hpp new file mode 100644 index 0000000..5d8b5d4 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spev.hpp @@ -0,0 +1,207 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spev( const char jobz, const UpLo, const fortran_int_t n, + float* ap, float* w, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSPEV( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spev( const char jobz, const UpLo, const fortran_int_t n, + double* ap, double* w, double* z, const fortran_int_t ldz, + double* work ) { + fortran_int_t info(0); + LAPACK_DSPEV( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spev. +// +template< typename Value > +struct spev_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::spev( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( jobz, ap, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( jobz, ap, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spev( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z, + Workspace work ) { + return spev_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, work ); +} + +// +// Overloaded function for spev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +spev( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z ) { + return spev_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/spevd.hpp new file mode 100644 index 0000000..81082f7 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spevd.hpp @@ -0,0 +1,248 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spevd( const char jobz, const UpLo, + const fortran_int_t n, float* ap, float* w, float* z, + const fortran_int_t ldz, float* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSPEVD( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spevd( const char jobz, const UpLo, + const fortran_int_t n, double* ap, double* w, double* z, + const fortran_int_t ldz, double* work, const fortran_int_t lwork, + fortran_int_t* iwork, const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSPEVD( &jobz, &lapack_option< UpLo >::value, &n, ap, w, z, &ldz, + work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spevd. +// +template< typename Value > +struct spevd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::spevd( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ap) ) ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, MatrixAP& ap, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::spevd( jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, ap, w, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n; + else + return 1 + 6*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spevd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spevd( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z, + Workspace work ) { + return spevd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, work ); +} + +// +// Overloaded function for spevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorW, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +spevd( const char jobz, MatrixAP& ap, VectorW& w, MatrixZ& z ) { + return spevd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, ap, w, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/spevx.hpp new file mode 100644 index 0000000..dcd23ef --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spevx.hpp @@ -0,0 +1,261 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, float* ap, const float vl, const float vu, + const fortran_int_t il, const fortran_int_t iu, const float abstol, + fortran_int_t& m, float* w, float* z, const fortran_int_t ldz, + float* work, fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSPEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, ap, &vl, + &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, ifail, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, double* ap, const double vl, const double vu, + const fortran_int_t il, const fortran_int_t iu, const double abstol, + fortran_int_t& m, double* w, double* z, const fortran_int_t ldz, + double* work, fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSPEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, ap, &vl, + &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, ifail, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spevx. +// +template< typename Value > +struct spevx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::spevx( jobz, range, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixAP& ap, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( jobz, range, ap, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spevx( const char jobz, const char range, MatrixAP& ap, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, Workspace work ) { + return spevx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, range, ap, vl, vu, il, iu, + abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for spevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename VectorW, typename MatrixZ, + typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +spevx( const char jobz, const char range, MatrixAP& ap, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail ) { + return spevx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( jobz, range, ap, vl, vu, il, iu, + abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spgv.hpp b/sdk/boost/numeric/bindings/lapack/driver/spgv.hpp new file mode 100644 index 0000000..521524b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spgv.hpp @@ -0,0 +1,222 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spgv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spgv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* ap, float* bp, float* w, + float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSPGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, w, + z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spgv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* ap, double* bp, double* w, + double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSPGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, w, + z, &ldz, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spgv. +// +template< typename Value > +struct spgv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::spgv( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( itype, jobz, ap, bp, w, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spgv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spgv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spgv( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) { + return spgv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, work ); +} + +// +// Overloaded function for spgv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +spgv( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z ) { + return spgv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spgvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/spgvd.hpp new file mode 100644 index 0000000..4f3fce9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spgvd.hpp @@ -0,0 +1,267 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spgvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spgvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* ap, float* bp, float* w, + float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSPGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spgvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* ap, double* bp, double* w, + double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSPGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, ap, bp, + w, z, &ldz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spgvd. +// +template< typename Value > +struct spgvd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::spgvd( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(ap) ) ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixAP& ap, MatrixBP& bp, VectorW& w, + MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::spgvd( itype, jobz, uplo(), bindings::size_column(ap), + bindings::begin_value(ap), bindings::begin_value(bp), + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( itype, jobz, ap, bp, w, z, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n; + else + return 1 + 6*n + n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spgvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spgvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spgvd( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z, Workspace work ) { + return spgvd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, work ); +} + +// +// Overloaded function for spgvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +spgvd( const fortran_int_t itype, const char jobz, MatrixAP& ap, + MatrixBP& bp, VectorW& w, MatrixZ& z ) { + return spgvd_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, ap, bp, w, z, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spgvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/spgvx.hpp new file mode 100644 index 0000000..fa09c5f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spgvx.hpp @@ -0,0 +1,275 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPGVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spgvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spgvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, float* ap, + float* bp, const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSPGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + ap, bp, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spgvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, double* ap, + double* bp, const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + fortran_int_t* iwork, fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSPGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + ap, bp, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, iwork, + ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spgvx. +// +template< typename Value > +struct spgvx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixBP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixBP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(ap) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::spgvx( itype, jobz, range, uplo(), + bindings::size_column(ap), bindings::begin_value(ap), + bindings::begin_value(bp), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m, + w, z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixAP& ap, MatrixBP& bp, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( itype, jobz, range, ap, bp, vl, vu, il, iu, abstol, m, + w, z, ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spgvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spgvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spgvx( const fortran_int_t itype, const char jobz, const char range, + MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return spgvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu, + il, iu, abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for spgvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixBP, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +spgvx( const fortran_int_t itype, const char jobz, const char range, + MatrixAP& ap, MatrixBP& bp, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixAP >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return spgvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( itype, jobz, range, ap, bp, vl, vu, + il, iu, abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spsv.hpp b/sdk/boost/numeric/bindings/lapack/driver/spsv.hpp new file mode 100644 index 0000000..c273ef3 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spsv.hpp @@ -0,0 +1,176 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spsv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, float* ap, fortran_int_t* ipiv, float* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_SSPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* ap, fortran_int_t* ipiv, double* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_DSPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* ap, + fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_CSPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* ap, + fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb ) { + fortran_int_t info(0); + LAPACK_ZSPSV( &lapack_option< UpLo >::value, &n, &nrhs, ap, ipiv, b, &ldb, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spsv. +// +template< typename Value > +struct spsv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixAP& ap, VectorIPIV& ipiv, MatrixB& b ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + return detail::spsv( uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(ipiv), bindings::begin_value(b), + bindings::stride_major(b) ); + } + +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spsv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spsv. Its overload differs for +// +template< typename MatrixAP, typename VectorIPIV, typename MatrixB > +inline std::ptrdiff_t spsv( MatrixAP& ap, VectorIPIV& ipiv, MatrixB& b ) { + return spsv_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( ap, ipiv, b ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/spsvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/spsvx.hpp new file mode 100644 index 0000000..adce7af --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/spsvx.hpp @@ -0,0 +1,457 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SPSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for spsvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const float* ap, + float* afp, fortran_int_t* ipiv, const float* b, + const fortran_int_t ldb, float* x, const fortran_int_t ldx, + float& rcond, float* ferr, float* berr, float* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const double* ap, + double* afp, fortran_int_t* ipiv, const double* b, + const fortran_int_t ldb, double* x, const fortran_int_t ldx, + double& rcond, double* ferr, double* berr, double* work, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, std::complex* afp, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float& rcond, float* ferr, float* berr, + std::complex* work, float* rwork ) { + fortran_int_t info(0); + LAPACK_CSPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t spsvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* ap, std::complex* afp, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + std::complex* work, double* rwork ) { + fortran_int_t info(0); + LAPACK_ZSPSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, ap, afp, + ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to spsvx. +// +template< typename Value, typename Enable = void > +struct spsvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct spsvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::spsvx( fact, uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(ap) ) ); + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 3*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct spsvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAFP >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixAP >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAFP >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(ap) )); + BOOST_ASSERT( bindings::size_column(ap) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(ap)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::spsvx( fact, uplo(), bindings::size_column(ap), + bindings::size_column(b), bindings::begin_value(ap), + bindings::begin_value(afp), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(ap) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(ap) ) ); + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixAP& ap, + MatrixAFP& afp, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixAP >::type uplo; + return invoke( fact, ap, afp, ipiv, b, x, rcond, ferr, berr, + minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 2*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the spsvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for spsvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +spsvx( const char fact, const MatrixAP& ap, MatrixAFP& afp, + VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr, + Workspace work ) { + return spsvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( fact, ap, afp, ipiv, b, x, rcond, + ferr, berr, work ); +} + +// +// Overloaded function for spsvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixAP, typename MatrixAFP, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +spsvx( const char fact, const MatrixAP& ap, MatrixAFP& afp, + VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + typename remove_imaginary< typename bindings::value_type< + MatrixAP >::type >::type& rcond, VectorFERR& ferr, VectorBERR& berr ) { + return spsvx_impl< typename bindings::value_type< + MatrixAP >::type >::invoke( fact, ap, afp, ipiv, b, x, rcond, + ferr, berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/stev.hpp b/sdk/boost/numeric/bindings/lapack/driver/stev.hpp new file mode 100644 index 0000000..4a556a8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/stev.hpp @@ -0,0 +1,200 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stev( const char jobz, const fortran_int_t n, float* d, + float* e, float* z, const fortran_int_t ldz, float* work ) { + fortran_int_t info(0); + LAPACK_SSTEV( &jobz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stev( const char jobz, const fortran_int_t n, double* d, + double* e, double* z, const fortran_int_t ldz, double* work ) { + fortran_int_t info(0); + LAPACK_DSTEV( &jobz, &n, d, e, z, &ldz, work, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stev. +// +template< typename Value > +struct stev_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK > + static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixZ& z, detail::workspace1< + WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + return detail::stev( jobz, n, bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + return invoke( jobz, n, d, e, z, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobz, n, d, e, z, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n-2 ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stev. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stev( const char jobz, const fortran_int_t n, VectorD& d, + VectorE& e, MatrixZ& z, Workspace work ) { + return stev_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, n, d, e, z, work ); +} + +// +// Overloaded function for stev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +stev( const char jobz, const fortran_int_t n, VectorD& d, + VectorE& e, MatrixZ& z ) { + return stev_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, n, d, e, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/stevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/stevd.hpp new file mode 100644 index 0000000..b90dd39 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/stevd.hpp @@ -0,0 +1,241 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stevd( const char jobz, const fortran_int_t n, float* d, + float* e, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSTEVD( &jobz, &n, d, e, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stevd( const char jobz, const fortran_int_t n, double* d, + double* e, double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSTEVD( &jobz, &n, d, e, z, &ldz, work, &lwork, iwork, &liwork, + &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stevd. +// +template< typename Value > +struct stevd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename MatrixZ, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixZ& z, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_ASSERT( bindings::size(e) >= n-1 ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, n )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + return detail::stevd( jobz, n, bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixZ& z, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, n ) ); + return invoke( jobz, n, d, e, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename MatrixZ > + static std::ptrdiff_t invoke( const char jobz, const fortran_int_t n, + VectorD& d, VectorE& e, MatrixZ& z, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stevd( jobz, n, bindings::begin_value(d), + bindings::begin_value(e), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, n, d, e, z, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 1 + 4*n + n*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stevd. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename MatrixZ, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stevd( const char jobz, const fortran_int_t n, VectorD& d, + VectorE& e, MatrixZ& z, Workspace work ) { + return stevd_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, n, d, e, z, work ); +} + +// +// Overloaded function for stevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename MatrixZ > +inline typename boost::disable_if< detail::is_workspace< MatrixZ >, + std::ptrdiff_t >::type +stevd( const char jobz, const fortran_int_t n, VectorD& d, + VectorE& e, MatrixZ& z ) { + return stevd_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, n, d, e, z, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/stevr.hpp b/sdk/boost/numeric/bindings/lapack/driver/stevr.hpp new file mode 100644 index 0000000..81d6cc8 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/stevr.hpp @@ -0,0 +1,282 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stevr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stevr( const char jobz, const char range, + const fortran_int_t n, float* d, float* e, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, float* z, + const fortran_int_t ldz, fortran_int_t* isuppz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSTEVR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stevr( const char jobz, const char range, + const fortran_int_t n, double* d, double* e, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, double* z, + const fortran_int_t ldz, fortran_int_t* isuppz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSTEVR( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, isuppz, work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stevr. +// +template< typename Value > +struct stevr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= std::max< std::ptrdiff_t >(1,n-1) ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stevr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), bindings::begin_value(isuppz), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::stevr( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), bindings::begin_value(isuppz), + &opt_size_work, -1, &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 20*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stevr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stevr. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stevr( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz, + Workspace work ) { + return stevr_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + abstol, m, w, z, isuppz, work ); +} + +// +// Overloaded function for stevr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorISUPPZ > +inline typename boost::disable_if< detail::is_workspace< VectorISUPPZ >, + std::ptrdiff_t >::type +stevr( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorISUPPZ& isuppz ) { + return stevr_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + abstol, m, w, z, isuppz, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/stevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/stevx.hpp new file mode 100644 index 0000000..85e4e00 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/stevx.hpp @@ -0,0 +1,267 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_STEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for stevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +inline std::ptrdiff_t stevx( const char jobz, const char range, + const fortran_int_t n, float* d, float* e, const float vl, + const float vu, const fortran_int_t il, const fortran_int_t iu, + const float abstol, fortran_int_t& m, float* w, float* z, + const fortran_int_t ldz, float* work, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSTEVX( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, work, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +inline std::ptrdiff_t stevx( const char jobz, const char range, + const fortran_int_t n, double* d, double* e, const double vl, + const double vu, const fortran_int_t il, const fortran_int_t iu, + const double abstol, fortran_int_t& m, double* w, double* z, + const fortran_int_t ldz, double* work, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSTEVX( &jobz, &range, &n, d, e, &vl, &vu, &il, &iu, &abstol, &m, + w, z, &ldz, work, iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to stevx. +// +template< typename Value > +struct stevx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorE >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorD >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorD >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorE >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(d) >= n ); + BOOST_ASSERT( bindings::size(e) >= std::max< std::ptrdiff_t >(1,n-1) ); + BOOST_ASSERT( bindings::size(w) >= n ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( n )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( n )); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( n >= 0 ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::stevx( jobz, range, n, bindings::begin_value(d), + bindings::begin_value(e), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + bindings::detail::array< real_type > tmp_work( min_size_work( n ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( n ) ); + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + const fortran_int_t n, VectorD& d, VectorE& e, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + return invoke( jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, + ifail, minimal_workspace() ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return 5*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the stevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for stevx. Its overload differs for +// * User-defined workspace +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +stevx( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return stevx_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for stevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename VectorD, typename VectorE, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +stevx( const char jobz, const char range, const fortran_int_t n, + VectorD& d, VectorE& e, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + VectorD >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< VectorD >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return stevx_impl< typename bindings::value_type< + VectorD >::type >::invoke( jobz, range, n, d, e, vl, vu, il, iu, + abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/syev.hpp b/sdk/boost/numeric/bindings/lapack/driver/syev.hpp new file mode 100644 index 0000000..da8ce43 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/syev.hpp @@ -0,0 +1,210 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for syev is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syev( const char jobz, const UpLo, const fortran_int_t n, + float* a, const fortran_int_t lda, float* w, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYEV( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syev( const char jobz, const UpLo, const fortran_int_t n, + double* a, const fortran_int_t lda, double* w, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYEV( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syev. +// +template< typename Value > +struct syev_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename WORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::syev( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( jobz, a, w, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::syev( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, a, w, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,3*n-1); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the syev_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syev. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +syev( const char jobz, MatrixA& a, VectorW& w, Workspace work ) { + return syev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, work ); +} + +// +// Overloaded function for syev. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +syev( const char jobz, MatrixA& a, VectorW& w ) { + return syev_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/syevd.hpp b/sdk/boost/numeric/bindings/lapack/driver/syevd.hpp new file mode 100644 index 0000000..8f2be13 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/syevd.hpp @@ -0,0 +1,243 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for syevd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syevd( const char jobz, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, float* w, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSYEVD( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syevd( const char jobz, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, double* w, + double* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSYEVD( &jobz, &lapack_option< UpLo >::value, &n, a, &lda, w, work, + &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syevd. +// +template< typename Value > +struct syevd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::syevd( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(a) ) ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW > + static std::ptrdiff_t invoke( const char jobz, MatrixA& a, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::syevd( jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(w), &opt_size_work, -1, &opt_size_iwork, + -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, a, w, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n + 1; + else + return 1 + 6*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the syevd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syevd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +syevd( const char jobz, MatrixA& a, VectorW& w, Workspace work ) { + return syevd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, work ); +} + +// +// Overloaded function for syevd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +syevd( const char jobz, MatrixA& a, VectorW& w ) { + return syevd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, a, w, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/syevr.hpp b/sdk/boost/numeric/bindings/lapack/driver/syevr.hpp new file mode 100644 index 0000000..8aa8231 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/syevr.hpp @@ -0,0 +1,286 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVR_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for syevr is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syevr( const char jobz, const char range, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, fortran_int_t* isuppz, + float* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSYEVR( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, isuppz, work, &lwork, + iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syevr( const char jobz, const char range, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, fortran_int_t* isuppz, + double* work, const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSYEVR( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, isuppz, work, &lwork, + iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syevr. +// +template< typename Value > +struct syevr_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorISUPPZ >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::syevr( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(isuppz), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::syevr( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(isuppz), &opt_size_work, -1, + &opt_size_iwork, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, + isuppz, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 26*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 10*n ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the syevr_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syevr. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +syevr( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz, Workspace work ) { + return syevr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, isuppz, work ); +} + +// +// Overloaded function for syevr. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorISUPPZ > +inline typename boost::disable_if< detail::is_workspace< VectorISUPPZ >, + std::ptrdiff_t >::type +syevr( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorISUPPZ& isuppz ) { + return syevr_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, isuppz, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/syevx.hpp b/sdk/boost/numeric/bindings/lapack/driver/syevx.hpp new file mode 100644 index 0000000..7cf96f9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/syevx.hpp @@ -0,0 +1,287 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYEVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for syevx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, float* a, const fortran_int_t lda, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSYEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, &lwork, iwork, + ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t syevx( const char jobz, const char range, const UpLo, + const fortran_int_t n, double* a, const fortran_int_t lda, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSYEVX( &jobz, &range, &lapack_option< UpLo >::value, &n, a, &lda, + &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, work, &lwork, iwork, + ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to syevx. +// +template< typename Value > +struct syevx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::syevx( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > + static std::ptrdiff_t invoke( const char jobz, const char range, + MatrixA& a, const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::syevx( jobz, range, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), vl, vu, + il, iu, abstol, m, bindings::begin_value(w), + bindings::begin_value(z), bindings::stride_major(z), + &opt_size_work, -1, bindings::begin_value(tmp_iwork), + bindings::begin_value(ifail) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( jobz, range, a, vl, vu, il, iu, abstol, m, w, z, ifail, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else + return 8*n; + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the syevx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for syevx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +syevx( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, Workspace work ) { + return syevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, ifail, work ); +} + +// +// Overloaded function for syevx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorW, typename MatrixZ, + typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +syevx( const char jobz, const char range, MatrixA& a, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vl, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vu, + const fortran_int_t il, const fortran_int_t iu, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail ) { + return syevx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( jobz, range, a, vl, vu, il, iu, abstol, + m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sygv.hpp b/sdk/boost/numeric/bindings/lapack/driver/sygv.hpp new file mode 100644 index 0000000..30f439b --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sygv.hpp @@ -0,0 +1,232 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sygv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* a, const fortran_int_t lda, + float* b, const fortran_int_t ldb, float* w, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygv( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* w, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYGV( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sygv. +// +template< typename Value > +struct sygv_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename WORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::sygv( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::sygv( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 3*n-1 ); + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sygv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sygv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sygv( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w, Workspace work ) { + return sygv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, work ); +} + +// +// Overloaded function for sygv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +sygv( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w ) { + return sygv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sygvd.hpp b/sdk/boost/numeric/bindings/lapack/driver/sygvd.hpp new file mode 100644 index 0000000..cc9573f --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sygvd.hpp @@ -0,0 +1,266 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGVD_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGVD_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sygvd is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, float* a, const fortran_int_t lda, + float* b, const fortran_int_t ldb, float* w, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_SSYGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, iwork, &liwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygvd( const fortran_int_t itype, const char jobz, + const UpLo, const fortran_int_t n, double* a, const fortran_int_t lda, + double* b, const fortran_int_t ldb, double* w, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + const fortran_int_t liwork ) { + fortran_int_t info(0); + LAPACK_DSYGVD( &itype, &jobz, &lapack_option< UpLo >::value, &n, a, &lda, + b, &ldb, w, work, &lwork, iwork, &liwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sygvd. +// +template< typename Value > +struct sygvd_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( jobz, bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + return detail::sygvd( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::size(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( jobz, + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( jobz, bindings::size_column(a) ) ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, MatrixA& a, MatrixB& b, VectorW& w, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + fortran_int_t opt_size_iwork; + detail::sygvd( itype, jobz, uplo(), bindings::size_column(a), + bindings::begin_value(a), bindings::stride_major(a), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(w), &opt_size_work, -1, &opt_size_iwork, + -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + opt_size_iwork ); + return invoke( itype, jobz, a, b, w, workspace( tmp_work, + tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const char jobz, + const std::ptrdiff_t n ) { + if ( n < 2 ) + return 1; + else { + if ( jobz == 'N' ) + return 2*n + 1; + else + return 1 + 6*n + 2*n*n; + } + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const char jobz, + const std::ptrdiff_t n ) { + if ( jobz == 'N' || n < 2 ) + return 1; + else + return 3 + 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sygvd_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sygvd. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sygvd( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w, Workspace work ) { + return sygvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, work ); +} + +// +// Overloaded function for sygvd. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorW > +inline typename boost::disable_if< detail::is_workspace< VectorW >, + std::ptrdiff_t >::type +sygvd( const fortran_int_t itype, const char jobz, MatrixA& a, + MatrixB& b, VectorW& w ) { + return sygvd_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, a, b, w, + optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sygvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/sygvx.hpp new file mode 100644 index 0000000..e6db0f9 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sygvx.hpp @@ -0,0 +1,305 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYGVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sygvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, float* a, + const fortran_int_t lda, float* b, const fortran_int_t ldb, + const float vl, const float vu, const fortran_int_t il, + const fortran_int_t iu, const float abstol, fortran_int_t& m, + float* w, float* z, const fortran_int_t ldz, float* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_SSYGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + a, &lda, b, &ldb, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, + work, &lwork, iwork, ifail, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sygvx( const fortran_int_t itype, const char jobz, + const char range, const UpLo, const fortran_int_t n, double* a, + const fortran_int_t lda, double* b, const fortran_int_t ldb, + const double vl, const double vu, const fortran_int_t il, + const fortran_int_t iu, const double abstol, fortran_int_t& m, + double* w, double* z, const fortran_int_t ldz, double* work, + const fortran_int_t lwork, fortran_int_t* iwork, + fortran_int_t* ifail ) { + fortran_int_t info(0); + LAPACK_DSYGVX( &itype, &jobz, &range, &lapack_option< UpLo >::value, &n, + a, &lda, b, &ldb, &vl, &vu, &il, &iu, &abstol, &m, w, z, &ldz, + work, &lwork, iwork, ifail, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sygvx. +// +template< typename Value > +struct sygvx_impl { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename WORK, + typename IWORK > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, detail::workspace2< WORK, + IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorW >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixZ >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorW >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixZ >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIFAIL >::value) ); + BOOST_ASSERT( bindings::size(w) >= bindings::size_column(a) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(z) == 1 || + bindings::stride_minor(z) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( jobz == 'N' || jobz == 'V' ); + BOOST_ASSERT( range == 'A' || range == 'V' || range == 'I' ); + return detail::sygvx( itype, jobz, range, uplo(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())), + bindings::begin_value(ifail) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > + static std::ptrdiff_t invoke( const fortran_int_t itype, + const char jobz, const char range, MatrixA& a, MatrixB& b, + const real_type vl, const real_type vu, + const fortran_int_t il, const fortran_int_t iu, + const real_type abstol, fortran_int_t& m, VectorW& w, + MatrixZ& z, VectorIFAIL& ifail, optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::sygvx( itype, jobz, range, uplo(), + bindings::size_column(a), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(b), + bindings::stride_major(b), vl, vu, il, iu, abstol, m, + bindings::begin_value(w), bindings::begin_value(z), + bindings::stride_major(z), &opt_size_work, -1, + bindings::begin_value(tmp_iwork), + bindings::begin_value(ifail) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( itype, jobz, range, a, b, vl, vu, il, iu, abstol, m, w, + z, ifail, workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >(1,8*n); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return 5*n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sygvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sygvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sygvx( const fortran_int_t itype, const char jobz, const char range, + MatrixA& a, MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail, + Workspace work ) { + return sygvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il, + iu, abstol, m, w, z, ifail, work ); +} + +// +// Overloaded function for sygvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixB, typename VectorW, + typename MatrixZ, typename VectorIFAIL > +inline typename boost::disable_if< detail::is_workspace< VectorIFAIL >, + std::ptrdiff_t >::type +sygvx( const fortran_int_t itype, const char jobz, const char range, + MatrixA& a, MatrixB& b, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type vl, + const typename remove_imaginary< typename bindings::value_type< + MatrixA >::type >::type vu, const fortran_int_t il, + const fortran_int_t iu, const typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type abstol, + fortran_int_t& m, VectorW& w, MatrixZ& z, VectorIFAIL& ifail ) { + return sygvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( itype, jobz, range, a, b, vl, vu, il, + iu, abstol, m, w, z, ifail, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sysv.hpp b/sdk/boost/numeric/bindings/lapack/driver/sysv.hpp new file mode 100644 index 0000000..6632865 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sysv.hpp @@ -0,0 +1,362 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYSV_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYSV_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sysv is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, float* a, const fortran_int_t lda, + fortran_int_t* ipiv, float* b, const fortran_int_t ldb, float* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_SSYSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, double* a, const fortran_int_t lda, + fortran_int_t* ipiv, double* b, const fortran_int_t ldb, double* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_DSYSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_CSYSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysv( const UpLo, const fortran_int_t n, + const fortran_int_t nrhs, std::complex* a, + const fortran_int_t lda, fortran_int_t* ipiv, std::complex* b, + const fortran_int_t ldb, std::complex* work, + const fortran_int_t lwork ) { + fortran_int_t info(0); + LAPACK_ZSYSV( &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, ipiv, b, + &ldb, work, &lwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sysv. +// +template< typename Value, typename Enable = void > +struct sysv_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sysv_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sysv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + detail::sysv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + &opt_size_work, -1 ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sysv_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename WORK > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + detail::workspace1< WORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixB >::value) ); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work()); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + return detail::sysv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work() ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename VectorIPIV, typename MatrixB > + static std::ptrdiff_t invoke( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + detail::sysv( uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + &opt_size_work, -1 ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( a, ipiv, b, workspace( tmp_work ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work() { + return 1; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sysv_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sysv. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB, + typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sysv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b, Workspace work ) { + return sysv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b, work ); +} + +// +// Overloaded function for sysv. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename VectorIPIV, typename MatrixB > +inline typename boost::disable_if< detail::is_workspace< MatrixB >, + std::ptrdiff_t >::type +sysv( MatrixA& a, VectorIPIV& ipiv, MatrixB& b ) { + return sysv_impl< typename bindings::value_type< + MatrixA >::type >::invoke( a, ipiv, b, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/driver/sysvx.hpp b/sdk/boost/numeric/bindings/lapack/driver/sysvx.hpp new file mode 100644 index 0000000..9d72c69 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/driver/sysvx.hpp @@ -0,0 +1,516 @@ +// +// Copyright (c) 2002--2010 +// Toon Knapen, Karl Meerbergen, Kresimir Fresl, +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// THIS FILE IS AUTOMATICALLY GENERATED +// PLEASE DO NOT EDIT! +// + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYSVX_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_DRIVER_SYSVX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// The LAPACK-backend for sysvx is the netlib-compatible backend. +// +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + +// +// The detail namespace contains value-type-overloaded functions that +// dispatch to the appropriate back-end LAPACK-routine. +// +namespace detail { + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * float value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const float* a, + const fortran_int_t lda, float* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const float* b, const fortran_int_t ldb, + float* x, const fortran_int_t ldx, float& rcond, float* ferr, + float* berr, float* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_SSYSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * double value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, const double* a, + const fortran_int_t lda, double* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const double* b, const fortran_int_t ldb, + double* x, const fortran_int_t ldx, double& rcond, double* ferr, + double* berr, double* work, const fortran_int_t lwork, + fortran_int_t* iwork ) { + fortran_int_t info(0); + LAPACK_DSYSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, iwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, float& rcond, float* ferr, float* berr, + std::complex* work, const fortran_int_t lwork, float* rwork ) { + fortran_int_t info(0); + LAPACK_CSYSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, rwork, &info ); + return info; +} + +// +// Overloaded function for dispatching to +// * netlib-compatible LAPACK backend (the default), and +// * complex value-type. +// +template< typename UpLo > +inline std::ptrdiff_t sysvx( const char fact, const UpLo, + const fortran_int_t n, const fortran_int_t nrhs, + const std::complex* a, const fortran_int_t lda, + std::complex* af, const fortran_int_t ldaf, + fortran_int_t* ipiv, const std::complex* b, + const fortran_int_t ldb, std::complex* x, + const fortran_int_t ldx, double& rcond, double* ferr, double* berr, + std::complex* work, const fortran_int_t lwork, + double* rwork ) { + fortran_int_t info(0); + LAPACK_ZSYSVX( &fact, &lapack_option< UpLo >::value, &n, &nrhs, a, &lda, + af, &ldaf, ipiv, b, &ldb, x, &ldx, &rcond, ferr, berr, work, + &lwork, rwork, &info ); + return info; +} + +} // namespace detail + +// +// Value-type based template class. Use this class if you need a type +// for dispatching to sysvx. +// +template< typename Value, typename Enable = void > +struct sysvx_impl {}; + +// +// This implementation is enabled if Value is a real type. +// +template< typename Value > +struct sysvx_impl< Value, typename boost::enable_if< is_real< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename IWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, IWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorFERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(fortran_int_t())) >= + min_size_iwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::sysvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(real_type())), + bindings::size(work.select(real_type())), + bindings::begin_value(work.select(fortran_int_t())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< real_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + real_type opt_size_work; + bindings::detail::array< fortran_int_t > tmp_iwork( + min_size_iwork( bindings::size_column(a) ) ); + detail::sysvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + &opt_size_work, -1, bindings::begin_value(tmp_iwork) ); + bindings::detail::array< real_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_iwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 3*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array iwork. + // + static std::ptrdiff_t min_size_iwork( const std::ptrdiff_t n ) { + return n; + } +}; + +// +// This implementation is enabled if Value is a complex type. +// +template< typename Value > +struct sysvx_impl< Value, typename boost::enable_if< is_complex< Value > >::type > { + + typedef Value value_type; + typedef typename remove_imaginary< Value >::type real_type; + + // + // Static member function for user-defined workspaces, that + // * Deduces the required arguments for dispatching to LAPACK, and + // * Asserts that most arguments make sense. + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename WORK, typename RWORK > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + detail::workspace2< WORK, RWORK > work ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixA >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixB >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_column_major< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< VectorFERR >::type >::type, + typename remove_const< typename bindings::value_type< + VectorBERR >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixAF >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixB >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (boost::is_same< typename remove_const< + typename bindings::value_type< MatrixA >::type >::type, + typename remove_const< typename bindings::value_type< + MatrixX >::type >::type >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixAF >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorIPIV >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< MatrixX >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorFERR >::value) ); + BOOST_STATIC_ASSERT( (bindings::is_mutable< VectorBERR >::value) ); + BOOST_ASSERT( bindings::size(berr) >= bindings::size_column(b) ); + BOOST_ASSERT( bindings::size(work.select(real_type())) >= + min_size_rwork( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size(work.select(value_type())) >= + min_size_work( bindings::size_column(a) )); + BOOST_ASSERT( bindings::size_column(a) >= 0 ); + BOOST_ASSERT( bindings::size_column(b) >= 0 ); + BOOST_ASSERT( bindings::size_minor(a) == 1 || + bindings::stride_minor(a) == 1 ); + BOOST_ASSERT( bindings::size_minor(af) == 1 || + bindings::stride_minor(af) == 1 ); + BOOST_ASSERT( bindings::size_minor(b) == 1 || + bindings::stride_minor(b) == 1 ); + BOOST_ASSERT( bindings::size_minor(x) == 1 || + bindings::stride_minor(x) == 1 ); + BOOST_ASSERT( bindings::stride_major(a) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(af) >= std::max< + std::ptrdiff_t >(1,bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(b) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( bindings::stride_major(x) >= std::max< std::ptrdiff_t >(1, + bindings::size_column(a)) ); + BOOST_ASSERT( fact == 'F' || fact == 'N' ); + return detail::sysvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + bindings::begin_value(work.select(value_type())), + bindings::size(work.select(value_type())), + bindings::begin_value(work.select(real_type())) ); + } + + // + // Static member function that + // * Figures out the minimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member function + // * Enables the unblocked algorithm (BLAS level 2) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + minimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + bindings::detail::array< value_type > tmp_work( min_size_work( + bindings::size_column(a) ) ); + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that + // * Figures out the optimal workspace requirements, and passes + // the results to the user-defined workspace overload of the + // invoke static member + // * Enables the blocked algorithm (BLAS level 3) + // + template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > + static std::ptrdiff_t invoke( const char fact, const MatrixA& a, + MatrixAF& af, VectorIPIV& ipiv, const MatrixB& b, MatrixX& x, + real_type& rcond, VectorFERR& ferr, VectorBERR& berr, + optimal_workspace ) { + namespace bindings = ::boost::numeric::bindings; + typedef typename result_of::uplo_tag< MatrixA >::type uplo; + value_type opt_size_work; + bindings::detail::array< real_type > tmp_rwork( min_size_rwork( + bindings::size_column(a) ) ); + detail::sysvx( fact, uplo(), bindings::size_column(a), + bindings::size_column(b), bindings::begin_value(a), + bindings::stride_major(a), bindings::begin_value(af), + bindings::stride_major(af), bindings::begin_value(ipiv), + bindings::begin_value(b), bindings::stride_major(b), + bindings::begin_value(x), bindings::stride_major(x), rcond, + bindings::begin_value(ferr), bindings::begin_value(berr), + &opt_size_work, -1, bindings::begin_value(tmp_rwork) ); + bindings::detail::array< value_type > tmp_work( + traits::detail::to_int( opt_size_work ) ); + return invoke( fact, a, af, ipiv, b, x, rcond, ferr, berr, + workspace( tmp_work, tmp_rwork ) ); + } + + // + // Static member function that returns the minimum size of + // workspace-array work. + // + static std::ptrdiff_t min_size_work( const std::ptrdiff_t n ) { + return std::max< std::ptrdiff_t >( 1, 2*n ); + } + + // + // Static member function that returns the minimum size of + // workspace-array rwork. + // + static std::ptrdiff_t min_size_rwork( const std::ptrdiff_t n ) { + return n; + } +}; + + +// +// Functions for direct use. These functions are overloaded for temporaries, +// so that wrapped types can still be passed and used for write-access. In +// addition, if applicable, they are overloaded for user-defined workspaces. +// Calls to these functions are passed to the sysvx_impl classes. In the +// documentation, most overloads are collapsed to avoid a large number of +// prototypes which are very similar. +// + +// +// Overloaded function for sysvx. Its overload differs for +// * User-defined workspace +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR, typename Workspace > +inline typename boost::enable_if< detail::is_workspace< Workspace >, + std::ptrdiff_t >::type +sysvx( const char fact, const MatrixA& a, MatrixAF& af, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr, Workspace work ) { + return sysvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, ipiv, b, x, rcond, ferr, + berr, work ); +} + +// +// Overloaded function for sysvx. Its overload differs for +// * Default workspace-type (optimal) +// +template< typename MatrixA, typename MatrixAF, typename VectorIPIV, + typename MatrixB, typename MatrixX, typename VectorFERR, + typename VectorBERR > +inline typename boost::disable_if< detail::is_workspace< VectorBERR >, + std::ptrdiff_t >::type +sysvx( const char fact, const MatrixA& a, MatrixAF& af, VectorIPIV& ipiv, + const MatrixB& b, MatrixX& x, typename remove_imaginary< + typename bindings::value_type< MatrixA >::type >::type& rcond, + VectorFERR& ferr, VectorBERR& berr ) { + return sysvx_impl< typename bindings::value_type< + MatrixA >::type >::invoke( fact, a, af, ipiv, b, x, rcond, ferr, + berr, optimal_workspace() ); +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lapack/workspace.hpp b/sdk/boost/numeric/bindings/lapack/workspace.hpp new file mode 100644 index 0000000..fa0d954 --- /dev/null +++ b/sdk/boost/numeric/bindings/lapack/workspace.hpp @@ -0,0 +1,202 @@ +/* + * + * Copyright (c) Karl Meerbergen & Kresimir Fresl 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * KF acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_WORKSPACE_HPP +#define BOOST_NUMERIC_BINDINGS_LAPACK_WORKSPACE_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace lapack { + + /* + * Organization of workspace in Lapack. + * We allow one of the following arguments in a number of Lapack functions + * - minimal_workspace() : the function allocates the minimum workspace required for the function + * - optimal_workspace() : the function allocates the amount of workspace that allows optimal + * execution. + * - workspace( work ) : the function uses the workspace array in work. + * - workspace( rwork, work ) : the function uses a real array rwork and a compolex array work as + * workspace. (There are Lapack functions for complex matrices + * that require two workarrays) + * */ + + + + // Four classes are introduced to distinguish between the different type of memory allocations + + struct minimal_workspace {} ; + + struct optimal_workspace {} ; + + namespace detail { + + template + class workspace1 { + public: + workspace1(W& w) + : w_( w ) + {} + + public: + typedef typename bindings::value_type< W>::type value_type ; + W& select( value_type const& ) { return w_ ; } + + private: + W& w_ ; + }; // struct workspace1 + + template + class workspace2 { + public: + workspace2(W& w, WRI& wri) + : w_(w) + , wri_(wri) + {} + + public: + typedef typename bindings::value_type< W>::type w_value_type ; + W& select( w_value_type const& ) { return w_ ; } + + typedef typename bindings::value_type< WRI>::type wri_value_type ; + WRI& select( wri_value_type const& ) { return wri_ ; } + + private: + W& w_ ; + WRI& wri_ ; + }; // struct workspace2 + + template + class workspace3 { + public: + workspace3(W& w, WR& wr, WI& wi) + : w_(w) + , wr_(wr) + , wi_(wi) + {} + + public: + typedef typename bindings::value_type< W>::type w_value_type ; + W& select( w_value_type const& ) { return w_ ; } + + typedef typename bindings::value_type< WR>::type wr_value_type ; + WR& select( wr_value_type const& ) { return wr_ ; } + + typedef typename bindings::value_type< WI>::type wi_value_type ; + WI& select( wi_value_type const& ) { return wi_ ; } + + private: + W& w_ ; + WR& wr_ ; + WI& wi_ ; + }; // struct workspace3 + + template + class workspace4 { + public: + workspace4(W& w, WR& wr, WI& wi, WB& wb) + : w_(w) + , wr_(wr) + , wi_(wi) + , wb_(wb) + {} + + public: + typedef typename bindings::value_type< W>::type w_value_type ; + W& select( w_value_type const& ) { return w_ ; } + + typedef typename bindings::value_type< WR>::type wr_value_type ; + WR& select( wr_value_type const& ) { return wr_ ; } + + typedef typename bindings::value_type< WI>::type wi_value_type ; + WI& select( wi_value_type const& ) { return wi_ ; } + + typedef typename bindings::value_type< WB>::type wb_value_type ; + WB& select( wb_value_type const& ) { return wb_ ; } + + private: + W& w_ ; + WR& wr_ ; + WI& wi_ ; + WB& wb_ ; + }; // struct workspace4 + + } + + template + detail::workspace1 workspace(W& w) { + return detail::workspace1(w) ; + } // workspace() + + // + // Two situations: + // Real valued: workspace( real array, integer array ) + // Complex valued: workspace( complex array, real array ) + // + template + detail::workspace2 workspace(W& w, WRI& wri) { + return detail::workspace2(w, wri) ; + } // workspace() + + // + // Complex valued: workspace( complex array, real array, integer array ) + // + template + detail::workspace3 workspace(W& w, WR& wr, WI& wi) { + return detail::workspace3(w, wr, wi) ; + } // workspace() + + // + // Complex valued: workspace( complex array, real array, integer array, bool array ) + // + template + detail::workspace4 workspace(W& w, WR& wr, WI& wi, WB& wb) { + return detail::workspace4(w, wr, wi, wb) ; + } // workspace() + + +namespace detail { + +template< typename T > +struct is_workspace: mpl::false_ {}; + +template<> +struct is_workspace< minimal_workspace >: mpl::true_ {}; + +template<> +struct is_workspace< optimal_workspace >: mpl::true_ {}; + +template< typename T > +struct is_workspace< workspace1 >: mpl::true_ {}; + +template< typename T1, typename T2 > +struct is_workspace< workspace2 >: mpl::true_ {}; + +template< typename T1, typename T2, typename T3 > +struct is_workspace< workspace3 >: mpl::true_ {}; + +template< typename T1, typename T2, typename T3, typename T4 > +struct is_workspace< workspace4 >: mpl::true_ {}; + +} + +} // namespace lapack +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/lower.hpp b/sdk/boost/numeric/bindings/lower.hpp new file mode 100644 index 0000000..516bef5 --- /dev/null +++ b/sdk/boost/numeric/bindings/lower.hpp @@ -0,0 +1,45 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_LOWER_HPP +#define BOOST_NUMERIC_BINDINGS_LOWER_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct lower { + typedef detail::basic_wrapper< + T, + mpl::pair< tag::matrix_type, tag::triangular >, + mpl::pair< tag::data_side, tag::lower > + > type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::lower< T >::type const lower( T& underlying ) { + return typename result_of::lower< T >::type( underlying ); +} + +template< typename T > +typename result_of::lower< const T >::type const lower( const T& underlying ) { + return typename result_of::lower< const T >::type( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/min_rank.hpp b/sdk/boost/numeric/bindings/min_rank.hpp new file mode 100644 index 0000000..31533e6 --- /dev/null +++ b/sdk/boost/numeric/bindings/min_rank.hpp @@ -0,0 +1,26 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MIN_RANK_HPP +#define BOOST_NUMERIC_BINDINGS_MIN_RANK_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +int min_rank( T const& t ) { +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/mtl/compressed2D.hpp b/sdk/boost/numeric/bindings/mtl/compressed2D.hpp new file mode 100644 index 0000000..5abcd0e --- /dev/null +++ b/sdk/boost/numeric/bindings/mtl/compressed2D.hpp @@ -0,0 +1,88 @@ +// +// Copyright (c) 2009--2010 +// Thomas Klimpel and Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MTL_COMPRESSED2D_HPP +#define BOOST_NUMERIC_BINDINGS_MTL_COMPRESSED2D_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Parameters, typename Id, typename Enable > +struct adaptor< mtl::compressed2D< T, Parameters >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename copy_const< + Id, + //typename Id::index_type + //typename Id::size_type // (Seems to be the actually used index_type) + std::ptrdiff_t // (Seems to be an actual usable type for bindings purposes) + >::type index_type; + typedef typename convert_to< + tag::data_order, + typename Parameters::orientation + >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::index_type, index_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::compressed_sparse >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::index_base, mpl::int_<0> > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.num_rows(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.num_cols(); + } + + static value_type* begin_value( Id& id ) { + return id.address_data(); + } + + static value_type* end_value( Id& id ) { + return id.address_data() + id.nnz(); + } + + static index_type* begin_compressed_index_major( Id& id ) { + return reinterpret_cast(id.address_major()); + } + + static index_type* end_compressed_index_major( Id& id ) { + return reinterpret_cast(id.address_major() + id.dim1() + 1); + } + + static index_type* begin_index_minor( Id& id ) { + return reinterpret_cast(id.address_minor()); + } + + static index_type* end_index_minor( Id& id ) { + return reinterpret_cast(id.address_minor() + id.nnz()); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/mtl/dense2D.hpp b/sdk/boost/numeric/bindings/mtl/dense2D.hpp new file mode 100644 index 0000000..cecb037 --- /dev/null +++ b/sdk/boost/numeric/bindings/mtl/dense2D.hpp @@ -0,0 +1,98 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MTL_DENSE2D_HPP +#define BOOST_NUMERIC_BINDINGS_MTL_DENSE2D_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Dimensions, int N > +struct mtl_matrix_size_type { + typedef std::ptrdiff_t type; +}; + +template< std::size_t Rows, std::size_t Cols > +struct mtl_matrix_size_type< mtl::fixed::dimensions< Rows, Cols >, 1 > { + typedef mpl::int_< Rows > type; +}; + +template< std::size_t Rows, std::size_t Cols > +struct mtl_matrix_size_type< mtl::fixed::dimensions< Rows, Cols >, 2 > { + typedef mpl::int_< Cols > type; +}; + +template< typename T, typename Parameters, typename Id, typename Enable > +struct adaptor< mtl::dense2D< T, Parameters >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename convert_to< + tag::data_order, + typename Parameters::orientation + >::type data_order; + typedef typename mtl_matrix_size_type< + typename Parameters::dimensions, + 1 + >::type size_type1; + typedef typename mtl_matrix_size_type< + typename Parameters::dimensions, + 2 + >::type size_type2; + + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, size_type1 >, + mpl::pair< tag::size_type<2>, size_type2 >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::stride_type<1>, + typename if_row_major< data_order, size_type2, tag::contiguous >::type >, + mpl::pair< tag::stride_type<2>, + typename if_row_major< data_order, tag::contiguous, size_type1 >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.num_rows(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.num_cols(); + } + + static value_type* begin_value( Id& id ) { + return id.elements(); + } + + static value_type* end_value( Id& id ) { + return id.elements() + id.used_memory(); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.num_cols(); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return id.num_rows(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/mtl/dense_vector.hpp b/sdk/boost/numeric/bindings/mtl/dense_vector.hpp new file mode 100644 index 0000000..13371f4 --- /dev/null +++ b/sdk/boost/numeric/bindings/mtl/dense_vector.hpp @@ -0,0 +1,71 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MTL_DENSE_VECTOR_HPP +#define BOOST_NUMERIC_BINDINGS_MTL_DENSE_VECTOR_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename Dimension > +struct mtl_vector_size_type { + typedef std::ptrdiff_t type; +}; + +template< std::size_t Size > +struct mtl_vector_size_type< mtl::vector::fixed::dimension< Size > > { + typedef mpl::int_< Size > type; +}; + +template< typename T, typename Parameters, typename Id, typename Enable > +struct adaptor< mtl::dense_vector< T, Parameters >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename convert_to< + tag::data_order, + typename Parameters::orientation + >::type data_order; + typedef typename mtl_vector_size_type< + typename Parameters::dimension + >::type size_type1; + + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, size_type1 >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return id.begin(); + } + + static value_type* end_value( Id& id ) { + return id.end(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/mtl/detail/convert_to.hpp b/sdk/boost/numeric/bindings/mtl/detail/convert_to.hpp new file mode 100644 index 0000000..1aabbfc --- /dev/null +++ b/sdk/boost/numeric/bindings/mtl/detail/convert_to.hpp @@ -0,0 +1,36 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MTL_DETAIL_CONVERT_TO_HPP +#define BOOST_NUMERIC_BINDINGS_MTL_DETAIL_CONVERT_TO_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template<> +struct convert_to< bindings::tag::data_order, mtl::tag::row_major > { + typedef bindings::tag::row_major type; +}; + +template<> +struct convert_to< bindings::tag::data_order, mtl::tag::col_major > { + typedef bindings::tag::column_major type; +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/mumps/4.6.4/cmumps_c.hpp b/sdk/boost/numeric/bindings/mumps/4.6.4/cmumps_c.hpp new file mode 100644 index 0000000..72077b8 --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/4.6.4/cmumps_c.hpp @@ -0,0 +1,118 @@ +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_CMUMPS_C_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_464_CMUMPS_C_HPP + +/* + + THIS FILE IS PART OF MUMPS VERSION 4.6.4 + This Version was built on Thu Jan 11 13:32:35 2007 + + + This version of MUMPS is provided to you free of charge. It is public + domain, based on public domain software developed during the Esprit IV + European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. + Since this first public domain version in 1999, the developments are + supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and + INRIA. + + Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, + Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. + + Up-to-date copies of the MUMPS package can be obtained + from the Web pages http://www.enseeiht.fr/apo/MUMPS/ + or http://graal.ens-lyon.fr/MUMPS + + + THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY + EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + + + User documentation of any code that uses this software can + include this complete notice. You can acknowledge (using + references [1], [2], and [3] the contribution of this package + in any scientific publication dependent upon the use of the + package. You shall use reasonable endeavours to notify + the authors of the package of this publication. + + [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, + Multifrontal parallel distributed symmetric and unsymmetric solvers, + in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). + + [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, + A fully asynchronous multifrontal solver using distributed dynamic + scheduling, SIAM Journal of Matrix Analysis and Applications, + Vol 23, No 1, pp 15-41 (2001). + + [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and + S. Pralet, Hybrid scheduling for the parallel solution of linear + systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). + +*/ +/* $Id: cmumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ +/* Mostly written in march 2002 (JYL) */ + +// This file is modified by Karl Meerbergen for C++ users + +/* Complex datatypes */ +typedef struct {float r,i;} mumps_complex; + +/* Next line defines CMUMPS_INT, CMUMPS_DOUBLE and CMUMPS_DOUBLE2 */ +#include "cmumps_prec.h" +/* + * Definition of the (simplified) + * MUMPS C structure + */ +typedef struct + { + CMUMPS_INT sym, par, job; + CMUMPS_INT comm_fortran; /* Fortran communicator */ + CMUMPS_INT icntl[40]; + CMUMPS_DOUBLE2 cntl[5]; + CMUMPS_INT n; + + CMUMPS_INT nz_alloc; /* used in matlab interface to decide if + we free + malloc when we have large variation */ + + /* Assembled entry */ + CMUMPS_INT nz; CMUMPS_INT *irn; CMUMPS_INT *jcn; CMUMPS_DOUBLE *a; + /* Distributed entry */ + CMUMPS_INT nz_loc; CMUMPS_INT *irn_loc; CMUMPS_INT *jcn_loc; CMUMPS_DOUBLE *a_loc; + /* Element entry */ + CMUMPS_INT nelt; CMUMPS_INT *eltptr; CMUMPS_INT *eltvar; CMUMPS_DOUBLE *a_elt; + + /* Ordering, if given by user */ + CMUMPS_INT *perm_in; + + /* Orderings returned to user */ + /* symmetric permutation */ + CMUMPS_INT *sym_perm; + /* column permutation */ + CMUMPS_INT *uns_perm; + + /* Scaling (input only in this version) */ + CMUMPS_DOUBLE *colsca; CMUMPS_DOUBLE *rowsca; + /* RHS, solution, ouptput data and statistics */ + CMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; + CMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; + CMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; + CMUMPS_INT schur_mloc, schur_nloc, schur_lld; + CMUMPS_INT mblock, nblock, nprow, npcol; + CMUMPS_INT info[40],infog[40]; + CMUMPS_DOUBLE2 rinfo[20], rinfog[20]; + /* Null space */ + CMUMPS_INT deficiency; CMUMPS_DOUBLE * nullspace; CMUMPS_INT * mapping; + /* Schur */ + CMUMPS_INT size_schur; CMUMPS_INT *listvar_schur; CMUMPS_DOUBLE *schur; + /* Internal parameters */ + CMUMPS_INT instance_number; + /* For out-of-core */ + char ooc_tmpdir[151]; + char ooc_prefix[151]; + } CMUMPS_STRUC_C; + + +extern "C" { + void cmumps_c(CMUMPS_STRUC_C * cmumps_par); +} + +#endif + diff --git a/sdk/boost/numeric/bindings/mumps/4.6.4/dmumps_c.hpp b/sdk/boost/numeric/bindings/mumps/4.6.4/dmumps_c.hpp new file mode 100644 index 0000000..ebde123 --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/4.6.4/dmumps_c.hpp @@ -0,0 +1,125 @@ +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_DMUMPS_C_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_464_DMUMPS_C_HPP + +/* + + THIS FILE IS PART OF MUMPS VERSION 4.6.4 + This Version was built on Thu Jan 11 13:32:35 2007 + + + This version of MUMPS is provided to you free of charge. It is public + domain, based on public domain software developed during the Esprit IV + European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. + Since this first public domain version in 1999, the developments are + supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and + INRIA. + + Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, + Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. + + Up-to-date copies of the MUMPS package can be obtained + from the Web pages http://www.enseeiht.fr/apo/MUMPS/ + or http://graal.ens-lyon.fr/MUMPS + + + THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY + EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + + + User documentation of any code that uses this software can + include this complete notice. You can acknowledge (using + references [1], [2], and [3] the contribution of this package + in any scientific publication dependent upon the use of the + package. You shall use reasonable endeavours to notify + the authors of the package of this publication. + + [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, + Multifrontal parallel distributed symmetric and unsymmetric solvers, + in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). + + [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, + A fully asynchronous multifrontal solver using distributed dynamic + scheduling, SIAM Journal of Matrix Analysis and Applications, + Vol 23, No 1, pp 15-41 (2001). + + [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and + S. Pralet, Hybrid scheduling for the parallel solution of linear + systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). + +*/ +/* $Id: dmumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ +/* Mostly written in march 2002 (JYL) */ + +// This file is modified by Karl Meerbergen for C++ users + +/* Complex datatypes */ + +/* Next line defines DMUMPS_INT, DMUMPS_DOUBLE and DMUMPS_DOUBLE2 */ +#include "dmumps_prec.h" +/* + * Definition of the (simplified) + * MUMPS C structure + */ +typedef struct + { + DMUMPS_INT sym, par, job; + DMUMPS_INT comm_fortran; /* Fortran communicator */ + DMUMPS_INT icntl[40]; + DMUMPS_DOUBLE2 cntl[5]; + DMUMPS_INT n; + + DMUMPS_INT nz_alloc; /* used in matlab interface to decide if + we free + malloc when we have large variation */ + + /* Assembled entry */ + DMUMPS_INT nz; DMUMPS_INT *irn; DMUMPS_INT *jcn; DMUMPS_DOUBLE *a; + /* Distributed entry */ + DMUMPS_INT nz_loc; DMUMPS_INT *irn_loc; DMUMPS_INT *jcn_loc; DMUMPS_DOUBLE *a_loc; + /* Element entry */ + DMUMPS_INT nelt; DMUMPS_INT *eltptr; DMUMPS_INT *eltvar; DMUMPS_DOUBLE *a_elt; + + /* Ordering, if given by user */ + DMUMPS_INT *perm_in; + + /* Orderings returned to user */ + /* symmetric permutation */ + DMUMPS_INT *sym_perm; + /* column permutation */ + DMUMPS_INT *uns_perm; + + /* Scaling (input only in this version) */ + DMUMPS_DOUBLE *colsca; DMUMPS_DOUBLE *rowsca; + /* RHS, solution, ouptput data and statistics */ + DMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; + DMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; + DMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; + DMUMPS_INT schur_mloc, schur_nloc, schur_lld; + DMUMPS_INT mblock, nblock, nprow, npcol; + DMUMPS_INT info[40],infog[40]; + DMUMPS_DOUBLE2 rinfo[20], rinfog[20]; + /* Null space */ + DMUMPS_INT deficiency; DMUMPS_DOUBLE * nullspace; DMUMPS_INT * mapping; + /* Schur */ + DMUMPS_INT size_schur; DMUMPS_INT *listvar_schur; DMUMPS_DOUBLE *schur; + /* Internal parameters */ + DMUMPS_INT instance_number; + /* For out-of-core */ + char ooc_tmpdir[151]; + char ooc_prefix[151]; + } DMUMPS_STRUC_C; + + +#define MUMPS_CALL +#if defined(_WIN32) +/* + * Next line May be needed depending on your Windows environment: + * #define MUMPS_CALL __stdcall + */ +#endif + +extern "C" { +void dmumps_c(DMUMPS_STRUC_C * dmumps_par); +} + +#endif + diff --git a/sdk/boost/numeric/bindings/mumps/4.6.4/smumps_c.hpp b/sdk/boost/numeric/bindings/mumps/4.6.4/smumps_c.hpp new file mode 100644 index 0000000..41212e2 --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/4.6.4/smumps_c.hpp @@ -0,0 +1,117 @@ +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_SMUMPS_C_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_464_SMUMPS_C_HPP + +/* + + THIS FILE IS PART OF MUMPS VERSION 4.6.4 + This Version was built on Thu Jan 11 13:32:35 2007 + + + This version of MUMPS is provided to you free of charge. It is public + domain, based on public domain software developed during the Esprit IV + European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. + Since this first public domain version in 1999, the developments are + supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and + INRIA. + + Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, + Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. + + Up-to-date copies of the MUMPS package can be obtained + from the Web pages http://www.enseeiht.fr/apo/MUMPS/ + or http://graal.ens-lyon.fr/MUMPS + + + THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY + EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + + + User documentation of any code that uses this software can + include this complete notice. You can acknowledge (using + references [1], [2], and [3] the contribution of this package + in any scientific publication dependent upon the use of the + package. You shall use reasonable endeavours to notify + the authors of the package of this publication. + + [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, + Multifrontal parallel distributed symmetric and unsymmetric solvers, + in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). + + [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, + A fully asynchronous multifrontal solver using distributed dynamic + scheduling, SIAM Journal of Matrix Analysis and Applications, + Vol 23, No 1, pp 15-41 (2001). + + [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and + S. Pralet, Hybrid scheduling for the parallel solution of linear + systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). + +*/ +/* $Id: smumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ +/* Mostly written in march 2002 (JYL) */ + +// This file is modified by Karl Meerbergen for C++ users + +/* Complex datatypes */ + +/* Next line defines SMUMPS_INT, SMUMPS_DOUBLE and SMUMPS_DOUBLE2 */ +#include +/* + * Definition of the (simplified) + * MUMPS C structure + */ +typedef struct + { + SMUMPS_INT sym, par, job; + SMUMPS_INT comm_fortran; /* Fortran communicator */ + SMUMPS_INT icntl[40]; + SMUMPS_DOUBLE2 cntl[5]; + SMUMPS_INT n; + + SMUMPS_INT nz_alloc; /* used in matlab interface to decide if + we free + malloc when we have large variation */ + + /* Assembled entry */ + SMUMPS_INT nz; SMUMPS_INT *irn; SMUMPS_INT *jcn; SMUMPS_DOUBLE *a; + /* Distributed entry */ + SMUMPS_INT nz_loc; SMUMPS_INT *irn_loc; SMUMPS_INT *jcn_loc; SMUMPS_DOUBLE *a_loc; + /* Element entry */ + SMUMPS_INT nelt; SMUMPS_INT *eltptr; SMUMPS_INT *eltvar; SMUMPS_DOUBLE *a_elt; + + /* Ordering, if given by user */ + SMUMPS_INT *perm_in; + + /* Orderings returned to user */ + /* symmetric permutation */ + SMUMPS_INT *sym_perm; + /* column permutation */ + SMUMPS_INT *uns_perm; + + /* Scaling (input only in this version) */ + SMUMPS_DOUBLE *colsca; SMUMPS_DOUBLE *rowsca; + /* RHS, solution, ouptput data and statistics */ + SMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; + SMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; + SMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; + SMUMPS_INT schur_mloc, schur_nloc, schur_lld; + SMUMPS_INT mblock, nblock, nprow, npcol; + SMUMPS_INT info[40],infog[40]; + SMUMPS_DOUBLE2 rinfo[20], rinfog[20]; + /* Null space */ + SMUMPS_INT deficiency; SMUMPS_DOUBLE * nullspace; SMUMPS_INT * mapping; + /* Schur */ + SMUMPS_INT size_schur; SMUMPS_INT *listvar_schur; SMUMPS_DOUBLE *schur; + /* Internal parameters */ + SMUMPS_INT instance_number; + /* For out-of-core */ + char ooc_tmpdir[151]; + char ooc_prefix[151]; + } SMUMPS_STRUC_C; + + +extern "C" { +void smumps_c(SMUMPS_STRUC_C * smumps_par); +} + +#endif + diff --git a/sdk/boost/numeric/bindings/mumps/4.6.4/zmumps_c.hpp b/sdk/boost/numeric/bindings/mumps/4.6.4/zmumps_c.hpp new file mode 100644 index 0000000..7777591 --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/4.6.4/zmumps_c.hpp @@ -0,0 +1,118 @@ +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_464_ZMUMPS_C_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_464_ZMUMPS_C_HPP + +/* + + THIS FILE IS PART OF MUMPS VERSION 4.6.4 + This Version was built on Thu Jan 11 13:32:35 2007 + + + This version of MUMPS is provided to you free of charge. It is public + domain, based on public domain software developed during the Esprit IV + European project PARASOL (1996-1999) by CERFACS, ENSEEIHT-IRIT and RAL. + Since this first public domain version in 1999, the developments are + supported by the following institutions: CERFACS, ENSEEIHT-IRIT, and + INRIA. + + Main contributors are Patrick Amestoy, Iain Duff, Abdou Guermouche, + Jacko Koster, Jean-Yves L'Excellent, and Stephane Pralet. + + Up-to-date copies of the MUMPS package can be obtained + from the Web pages http://www.enseeiht.fr/apo/MUMPS/ + or http://graal.ens-lyon.fr/MUMPS + + + THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY + EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + + + User documentation of any code that uses this software can + include this complete notice. You can acknowledge (using + references [1], [2], and [3] the contribution of this package + in any scientific publication dependent upon the use of the + package. You shall use reasonable endeavours to notify + the authors of the package of this publication. + + [1] P. R. Amestoy, I. S. Duff and J.-Y. L'Excellent, + Multifrontal parallel distributed symmetric and unsymmetric solvers, + in Comput. Methods in Appl. Mech. Eng., 184, 501-520 (2000). + + [2] P. R. Amestoy, I. S. Duff, J. Koster and J.-Y. L'Excellent, + A fully asynchronous multifrontal solver using distributed dynamic + scheduling, SIAM Journal of Matrix Analysis and Applications, + Vol 23, No 1, pp 15-41 (2001). + + [3] P. R. Amestoy and A. Guermouche and J.-Y. L'Excellent and + S. Pralet, Hybrid scheduling for the parallel solution of linear + systems. Parallel Computing Vol 32 (2), pp 136-156 (2006). + +*/ +/* $Id: zmumps_c.hpp 39206 2007-09-12 06:58:12Z karlmeerbergen $ */ +/* Mostly written in march 2002 (JYL) */ + +// This file is modified by Karl Meerbergen for C++ users + +/* Complex datatypes */ +typedef struct {double r,i;} mumps_double_complex; + +/* Next line defines ZMUMPS_INT, ZMUMPS_DOUBLE and ZMUMPS_DOUBLE2 */ +#include "zmumps_prec.h" +/* + * Definition of the (simplified) + * MUMPS C structure + */ +typedef struct + { + ZMUMPS_INT sym, par, job; + ZMUMPS_INT comm_fortran; /* Fortran communicator */ + ZMUMPS_INT icntl[40]; + ZMUMPS_DOUBLE2 cntl[5]; + ZMUMPS_INT n; + + ZMUMPS_INT nz_alloc; /* used in matlab interface to decide if + we free + malloc when we have large variation */ + + /* Assembled entry */ + ZMUMPS_INT nz; ZMUMPS_INT *irn; ZMUMPS_INT *jcn; ZMUMPS_DOUBLE *a; + /* Distributed entry */ + ZMUMPS_INT nz_loc; ZMUMPS_INT *irn_loc; ZMUMPS_INT *jcn_loc; ZMUMPS_DOUBLE *a_loc; + /* Element entry */ + ZMUMPS_INT nelt; ZMUMPS_INT *eltptr; ZMUMPS_INT *eltvar; ZMUMPS_DOUBLE *a_elt; + + /* Ordering, if given by user */ + ZMUMPS_INT *perm_in; + + /* Orderings returned to user */ + /* symmetric permutation */ + ZMUMPS_INT *sym_perm; + /* column permutation */ + ZMUMPS_INT *uns_perm; + + /* Scaling (input only in this version) */ + ZMUMPS_DOUBLE *colsca; ZMUMPS_DOUBLE *rowsca; + /* RHS, solution, ouptput data and statistics */ + ZMUMPS_DOUBLE *rhs, *rhs_sparse, *sol_loc; + ZMUMPS_INT *irhs_sparse, *irhs_ptr, *isol_loc; + ZMUMPS_INT nrhs, lrhs, nz_rhs, lsol_loc; + ZMUMPS_INT schur_mloc, schur_nloc, schur_lld; + ZMUMPS_INT mblock, nblock, nprow, npcol; + ZMUMPS_INT info[40],infog[40]; + ZMUMPS_DOUBLE2 rinfo[20], rinfog[20]; + /* Null space */ + ZMUMPS_INT deficiency; ZMUMPS_DOUBLE * nullspace; ZMUMPS_INT * mapping; + /* Schur */ + ZMUMPS_INT size_schur; ZMUMPS_INT *listvar_schur; ZMUMPS_DOUBLE *schur; + /* Internal parameters */ + ZMUMPS_INT instance_number; + /* For out-of-core */ + char ooc_tmpdir[151]; + char ooc_prefix[151]; + } ZMUMPS_STRUC_C; + + +extern "C" { +void zmumps_c(ZMUMPS_STRUC_C * zmumps_par); +} + +#endif + diff --git a/sdk/boost/numeric/bindings/mumps/mumps_driver.hpp b/sdk/boost/numeric/bindings/mumps/mumps_driver.hpp new file mode 100644 index 0000000..92482cd --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/mumps_driver.hpp @@ -0,0 +1,14 @@ +// +// Copyright Karl Meerbergen 2007 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_HPP + +#include + +#endif diff --git a/sdk/boost/numeric/bindings/mumps/mumps_driver_4_6_4.hpp b/sdk/boost/numeric/bindings/mumps/mumps_driver_4_6_4.hpp new file mode 100644 index 0000000..ade3349 --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/mumps_driver_4_6_4.hpp @@ -0,0 +1,264 @@ +// +// Copyright Karl Meerbergen 2007 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_4_6_4_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_4_6_4_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// This file contains a C++ driver for MUMPS +// +// The templated class mumps is a wrapper for the corresponding C struct. +// The class contains constructor and destructor that call mumps with JOB=-1 and JOB=-2 +// respectively. +// +// The function driver() calls MUMPS. The user must set the parameters of the data manually. +// +// The following functions are very helpful in this respect, since they extract pointer and size +// data using the Boost Bindings. +// +// void matrix_integer_data() : to set the integer data of the matrix. +// void matrix_value_data() : to set the values of the matrix. +// void rhs_sol_value_data() : to set the right-hand side and solution vectors in the case of a dense solution vector. +// + +namespace boost { namespace numeric { namespace bindings { namespace mumps { + + namespace detail { + // + // Type and Driver + // + template + struct mumps_type { + } ; + + template + struct mumps_call { + } ; + + template + struct mumps_internal_value_type { + typedef T type ; + } ; + + // + // Specialization for float + // + + template <> + struct mumps_type< float > { + typedef SMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< float > { + void operator() ( SMUMPS_STRUC_C& struc ) const { + smumps_c( &struc ) ; + } + } ; + + // + // Specialization for double + // + + template <> + struct mumps_type< double > { + typedef DMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< double > { + void operator() ( DMUMPS_STRUC_C& struc ) const { + dmumps_c( &struc ) ; + } + } ; + + // + // Specialization for complex + // + + template <> + struct mumps_type< std::complex< float > > { + typedef CMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< std::complex< float > > { + void operator() ( CMUMPS_STRUC_C& struc ) const { + cmumps_c( &struc ) ; + } + } ; + + template <> + struct mumps_internal_value_type< std::complex > { + typedef mumps_complex type ; + } ; + + // + // Specialization for complex + // + + template <> + struct mumps_type< std::complex< double > > { + typedef ZMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< std::complex< double > > { + void operator() ( ZMUMPS_STRUC_C& struc ) const { + zmumps_c( &struc ) ; + } + } ; + + template <> + struct mumps_internal_value_type< std::complex > { + typedef mumps_double_complex type ; + } ; + + // + // Symmetry map + // + + template + struct mumps_sym { + } ; + + template <> + struct mumps_sym< bindings::tag::symmetric > { + static int const value = 2 ; + } ; + + template <> + struct mumps_sym< bindings::tag::general > { + static int const value = 0 ; + } ; + + // + // Get index pointers + // + template + void indices( bindings::tag::row_major, int*& rows, int*& cols, M const& m ) { + rows = const_cast( bindings::begin_index_major( m ) ) ; + cols = const_cast( bindings::begin_index_minor( m ) ) ; + } + + template + void indices( bindings::tag::column_major, int*& rows, int*& cols, M const& m ) { + cols = const_cast( bindings::begin_index_major( m ) ) ; + rows = const_cast( bindings::begin_index_minor( m ) ) ; + } + + // Pointer Cast + float* cast_2_mumps( float* p ) { return p ; } + double* cast_2_mumps( double* p ) { return p ; } + mumps_double_complex* cast_2_mumps( std::complex* p ) { return reinterpret_cast( p ) ; } + mumps_complex* cast_2_mumps( std::complex* p ) { return reinterpret_cast( p ) ; } + } // namespace detail + + + + // + // Generic MUMPS data for any value_type + // + template + struct mumps + : detail::mumps_type< typename bindings::value_type::type >::type + { + typedef typename bindings::value_type::type value_type ; + typedef typename detail::mumps_type< typename bindings::value_type::type >::type c_struct_type ; + + // + // Initialize MUMPS solver + // Pass a communicator (comm=-987654 means choose default) + // Pass 'par': default = 1: host is involved in factorization + // + mumps( int comm_fortran=-987654, int par=1 ) + { + this->job = -1 ; + this->par = par ; + this->comm_fortran = comm_fortran ; + this->sym = detail::mumps_sym< typename bindings::detail::property_at::type >::value ; + detail::mumps_call() ( *this ) ; + } + + // Destroy the solver + ~mumps() { + this->job = -2 ; + detail::mumps_call() ( *this ) ; + } + } ; + + + // + // Copy the matrix integer data (matrix order, structure) to the MUMPS struct + // + template + void matrix_integer_data( mumps& data, M& m ) { + typedef typename bindings::result_of::index_base::type index_b ; + BOOST_STATIC_ASSERT(index_b::value == 1) ; + data.n = bindings::size_row( m ) ; + assert( bindings::size_column( m ) == data.n ) ; + + data.nz = bindings::end_value( m ) - bindings::begin_value( m ) ; + detail::indices( bindings::data_order(m), data.irn, data.jcn, m ) ; + + data.nz_loc = bindings::end_value( m ) - bindings::begin_value( m ) ; + detail::indices( bindings::data_order(m), data.irn_loc, data.jcn_loc, m ) ; + } // matrix_integer_data() + + + // + // Copy the values pointer to the MUMPS struct + // + template + void matrix_value_data( mumps& data, M& m ) { + data.a = detail::cast_2_mumps( bindings::begin_value( m ) ) ; + data.a_loc = detail::cast_2_mumps( bindings::begin_value( m ) ) ; + } // matrix_value_data() + + + // + // Copy the right-hand side / solution pointer to the MUMPS struct + // in case of a dense undistributed right-hand side and solution. + // + template + void rhs_sol_value_data( mumps& data, X& x ) { + data.rhs = detail::cast_2_mumps( bindings::begin_value( x ) ) ; + data.nrhs = bindings::size_column( x ) ; + data.lrhs = bindings::stride_major( x ) ; + } // matrix_rhs_sol_value_data() + + + // + // Call the MUMPS driver for the given MUMPS struct. + // + template + int driver( mumps& data ) { + assert( data.job>=1 ? data.irn!=0 : true ) ; + assert( data.job>=1 ? data.jcn!=0 : true ) ; + assert( data.job>=2 ? data.a!=0 : true ) ; + assert( data.job>=3 ? data.rhs!=0 : true ) ; + detail::mumps_call() ( static_cast::c_struct_type&>( data ) ) ; + return data.info[0] ; + } // driver() + +} } } } // namespace boost::numeric::bindings::mumps + +#endif diff --git a/sdk/boost/numeric/bindings/mumps/mumps_driver_4_8_0.hpp b/sdk/boost/numeric/bindings/mumps/mumps_driver_4_8_0.hpp new file mode 100644 index 0000000..1624c9a --- /dev/null +++ b/sdk/boost/numeric/bindings/mumps/mumps_driver_4_8_0.hpp @@ -0,0 +1,271 @@ +// +// Copyright Karl Meerbergen 2008 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_4_8_0_HPP +#define BOOST_NUMERIC_BINDINGS_MUMPS_MUMPS_DRIVER_4_8_0_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// This file contains a C++ driver for MUMPS +// +// The templated class mumps is a wrapper for the corresponding C struct. +// The class contains constructor and destructor that call mumps with JOB=-1 and JOB=-2 +// respectively. +// +// The function driver() calls MUMPS. The user must set the parameters of the data manually. +// +// The following functions are very helpful in this respect, since they extract pointer and size +// data using the Boost Bindings. +// +// void matrix_integer_data() : to set the integer data of the matrix. +// void matrix_value_data() : to set the values of the matrix. +// void rhs_sol_value_data() : to set the right-hand side and solution vectors in the case of a dense solution vector. +// + +namespace boost { namespace numeric { namespace bindings { namespace mumps { + + namespace detail { + // + // Type and Driver + // + template + struct mumps_type { + } ; + + template + struct mumps_call { + } ; + + template + struct mumps_internal_value_type { + typedef T type ; + } ; + + // + // Specialization for float + // + + template <> + struct mumps_type< float > { + typedef SMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< float > { + void operator() ( SMUMPS_STRUC_C& struc ) const { + smumps_c( &struc ) ; + } + } ; + + // + // Specialization for double + // + + template <> + struct mumps_type< double > { + typedef DMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< double > { + void operator() ( DMUMPS_STRUC_C& struc ) const { + dmumps_c( &struc ) ; + } + } ; + + // + // Specialization for complex + // + + template <> + struct mumps_type< std::complex< float > > { + typedef CMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< std::complex< float > > { + void operator() ( CMUMPS_STRUC_C& struc ) const { + cmumps_c( &struc ) ; + } + } ; + + template <> + struct mumps_internal_value_type< std::complex > { + typedef mumps_complex type ; + } ; + + // + // Specialization for complex + // + + template <> + struct mumps_type< std::complex< double > > { + typedef ZMUMPS_STRUC_C type ; + } ; + + template <> + struct mumps_call< std::complex< double > > { + void operator() ( ZMUMPS_STRUC_C& struc ) const { + zmumps_c( &struc ) ; + } + } ; + + template <> + struct mumps_internal_value_type< std::complex > { + typedef mumps_double_complex type ; + } ; + + // + // Symmetry map + // + + template + struct mumps_sym { + } ; + + template <> + struct mumps_sym< bindings::tag::symmetric > { + static int const value = 2 ; + } ; + + template <> + struct mumps_sym< bindings::tag::general > { + static int const value = 0 ; + } ; + + // + // Get index pointers + // + template + void indices( bindings::tag::row_major, int*& rows, int*& cols, M const& m ) { + rows = const_cast( bindings::begin_index_major( m ) ) ; + cols = const_cast( bindings::begin_index_minor( m ) ) ; + } + + template + void indices( bindings::tag::column_major, int*& rows, int*& cols, M const& m ) { + cols = const_cast( bindings::begin_index_major( m ) ) ; + rows = const_cast( bindings::begin_index_minor( m ) ) ; + } + + // Pointer Cast + float* cast_2_mumps( float* p ) { return p ; } + double* cast_2_mumps( double* p ) { return p ; } + mumps_double_complex* cast_2_mumps( std::complex* p ) { return reinterpret_cast( p ) ; } + mumps_complex* cast_2_mumps( std::complex* p ) { return reinterpret_cast( p ) ; } + } // namespace detail + + + + // + // Generic MUMPS data for any value_type + // + template + class mumps + : public detail::mumps_type< typename bindings::value_type::type >::type + { + public: + typedef typename bindings::value_type::type value_type ; + typedef typename detail::mumps_type< typename bindings::value_type::type >::type c_struct_type ; + + // + // Initialize MUMPS solver + // Pass a communicator (comm=-987654 means choose default) + // Pass 'par': default = 1: host is involved in factorization + // + mumps( int comm_fortran=-987654, int par=1 ) + { + this->job = -1 ; + this->par = par ; + this->comm_fortran = comm_fortran ; + this->sym = detail::mumps_sym< typename bindings::detail::property_at::type >::value ; + detail::mumps_call() ( *this ) ; + } + + // Destroy the solver + ~mumps() { + this->job = -2 ; + detail::mumps_call() ( *this ) ; + } + + private: + // Disable assignment and Copy Constructor + mumps& operator=( mumps const& that ) { return *this ; } + + mumps( mumps const& that ) {} + } ; + + + // + // Copy the matrix integer data (matrix order, structure) to the MUMPS struct + // + template + void matrix_integer_data( mumps& data, M& m ) { + typedef typename bindings::result_of::index_base::type index_b ; + BOOST_STATIC_ASSERT(index_b::value == 1) ; + data.n = bindings::size_row( m ) ; + assert( bindings::size_column( m ) == data.n ) ; + + data.nz = bindings::end_value( m ) - bindings::begin_value( m ) ; + detail::indices( bindings::data_order(m), data.irn, data.jcn, m ) ; + + data.nz_loc = bindings::end_value( m ) - bindings::begin_value( m ) ; + detail::indices( bindings::data_order(m), data.irn_loc, data.jcn_loc, m ) ; + } // matrix_integer_data() + + + // + // Copy the values pointer to the MUMPS struct + // + template + void matrix_value_data( mumps& data, M& m ) { + data.a = detail::cast_2_mumps( bindings::begin_value( m ) ) ; + data.a_loc = detail::cast_2_mumps( bindings::begin_value( m ) ) ; + } // matrix_value_data() + + + // + // Copy the right-hand side / solution pointer to the MUMPS struct + // in case of a dense undistributed right-hand side and solution. + // + template + void rhs_sol_value_data( mumps& data, X& x ) { + data.rhs = detail::cast_2_mumps( bindings::begin_value( x ) ) ; + data.nrhs = bindings::size_column( x ) ; + data.lrhs = bindings::stride_major( x ) ; + } // matrix_rhs_sol_value_data() + + + // + // Call the MUMPS driver for the given MUMPS struct. + // + template + int driver( mumps& data ) { + assert( data.job>=1 ? data.irn!=0 : true ) ; + assert( data.job>=1 ? data.jcn!=0 : true ) ; + assert( data.job>=2 ? data.a!=0 : true ) ; + assert( data.job==3 || data.job==5 ? data.rhs!=0 : true ) ; + detail::mumps_call() ( static_cast::c_struct_type&>( data ) ) ; + return data.info[0] ; + } // driver() + +} } } } // namespace boost::numeric::bindings::mumps + +#endif diff --git a/sdk/boost/numeric/bindings/noop.hpp b/sdk/boost/numeric/bindings/noop.hpp new file mode 100644 index 0000000..e6c24d8 --- /dev/null +++ b/sdk/boost/numeric/bindings/noop.hpp @@ -0,0 +1,61 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_NOOP_HPP +#define BOOST_NUMERIC_BINDINGS_NOOP_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T > +struct noop_wrapper: + adaptable_type< noop_wrapper >, + reference_wrapper { + noop_wrapper( T& t ): reference_wrapper( t ) {} +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< noop_wrapper, Id, Enable >: + basic_unwrapper< T, Id > { + + typedef typename property_map_of< T >::type property_map; + +}; + +} // namespace detail + +namespace result_of { + +template< typename T > +struct noop { + typedef detail::noop_wrapper type; +}; + +} // namespace result_of + +template< typename T > +detail::noop_wrapper const noop( T& underlying ) { + return detail::noop_wrapper( underlying ); +} + +template< typename T > +detail::noop_wrapper const noop( const T& underlying ) { + return detail::noop_wrapper( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/num_columns.hpp b/sdk/boost/numeric/bindings/num_columns.hpp new file mode 100644 index 0000000..ad553de --- /dev/null +++ b/sdk/boost/numeric/bindings/num_columns.hpp @@ -0,0 +1,35 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_NUM_COLUMNS_HPP +#define BOOST_NUMERIC_BINDINGS_NUM_COLUMNS_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct num_columns { + typedef typename result_of::size2::type type; +}; + +} // namespace result_of + +template< typename T > +inline typename result_of::num_columns::type num_columns( const T& t ) { + return size2( t ); +} + +} // bindings +} // numeric +} // boost + +#endif diff --git a/sdk/boost/numeric/bindings/num_rows.hpp b/sdk/boost/numeric/bindings/num_rows.hpp new file mode 100644 index 0000000..30bbc7f --- /dev/null +++ b/sdk/boost/numeric/bindings/num_rows.hpp @@ -0,0 +1,35 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_NUM_ROWS_HPP +#define BOOST_NUMERIC_BINDINGS_NUM_ROWS_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct num_rows { + typedef typename result_of::size1::type type; +}; + +} // namespace result_of + +template< typename T > +inline typename result_of::num_rows::type num_rows( const T& t ) { + return size1( t ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/rank.hpp b/sdk/boost/numeric/bindings/rank.hpp new file mode 100644 index 0000000..d7c5994 --- /dev/null +++ b/sdk/boost/numeric/bindings/rank.hpp @@ -0,0 +1,25 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_RANK_HPP +#define BOOST_NUMERIC_BINDINGS_RANK_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct rank: mpl::int_< detail::property_at< T, tag::entity >::type::value > {}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/remove_imaginary.hpp b/sdk/boost/numeric/bindings/remove_imaginary.hpp new file mode 100644 index 0000000..6403578 --- /dev/null +++ b/sdk/boost/numeric/bindings/remove_imaginary.hpp @@ -0,0 +1,37 @@ +// +// Copyright (c) 2009 by Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_REMOVE_IMAGINARY_HPP +#define BOOST_NUMERIC_BINDINGS_REMOVE_IMAGINARY_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct remove_imaginary { + typedef T type; +}; + +template< typename T > +struct remove_imaginary< std::complex > { + typedef T type; +}; + +template< typename T > +struct remove_imaginary< const std::complex > { + typedef const T type; +}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/row.hpp b/sdk/boost/numeric/bindings/row.hpp new file mode 100644 index 0000000..f923224 --- /dev/null +++ b/sdk/boost/numeric/bindings/row.hpp @@ -0,0 +1,100 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_ROW_HPP +#define BOOST_NUMERIC_BINDINGS_ROW_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T > +struct row_wrapper: + adaptable_type< row_wrapper >, + reference_wrapper { + + row_wrapper( T& t, std::size_t index ): + reference_wrapper(t), + m_index( index ) {} + + std::size_t m_index; +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< row_wrapper, Id, Enable > { + + typedef typename bindings::value_type< T>::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, typename result_of::size2::type >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, typename result_of::stride2::type > + > property_map; + + static typename result_of::size2::type size1( const Id& id ) { + return bindings::size2( id.get() ); + } + + static typename result_of::begin_value< T >::type begin_value( Id& id ) { + return bindings::begin_value( id.get() ) + + offset( id.get(), id.m_index, 0 ); + } + + static typename result_of::end_value< T >::type end_value( Id& id ) { + return bindings::begin_value( id.get() ) + + offset( id.get(), id.m_index, size1(id) ); + } + + static typename result_of::stride2::type stride1( const Id& id ) { + return bindings::stride2( id.get() ); + } + +}; + +} // namespace detail + +namespace result_of { + +template< typename T > +struct row { + typedef detail::row_wrapper type; +}; + +} // namespace result_of + +template< typename T > +detail::row_wrapper const row( T& underlying, std::size_t index ) { + return detail::row_wrapper( underlying, index ); +} + +template< typename T > +detail::row_wrapper const row( const T& underlying, std::size_t index ) { + return detail::row_wrapper( underlying, index ); +} + +template< int N, typename T > +void row( const T& underlying ) { + +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/size.hpp b/sdk/boost/numeric/bindings/size.hpp new file mode 100644 index 0000000..6a552b1 --- /dev/null +++ b/sdk/boost/numeric/bindings/size.hpp @@ -0,0 +1,155 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_SIZE_HPP +#define BOOST_NUMERIC_BINDINGS_SIZE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename AddressingIndex, typename Enable = void > +struct size_impl { + + typedef typename tag::size_type< AddressingIndex::value > key_type; + typedef typename result_of_get< T, key_type >::type result_type; + + static result_type invoke( const T& t ) { + return get< key_type >( t ); + } + +}; + +template< typename T, typename AddressingIndex > +struct size_impl< T, AddressingIndex, + typename boost::enable_if< typename mpl::and_< + mpl::greater< AddressingIndex, rank >, + is_same_at< T, tag::size_type<1>, std::ptrdiff_t > + >::type >::type > { + + typedef std::ptrdiff_t result_type; + + static result_type invoke( const T& t ) { + return std::min< std::ptrdiff_t >( size_impl >::invoke(t), 1 ); + } + +}; + +template< typename T, typename AddressingIndex > +struct size_impl< T, AddressingIndex, + typename boost::enable_if< typename mpl::and_< + mpl::greater< AddressingIndex, rank >, + mpl::not_< is_same_at< T, tag::size_type<1>, std::ptrdiff_t > > + >::type >::type > { + + typedef typename mpl::min< + typename detail::property_at< T, tag::size_type<1> >::type, + mpl::int_<1> + >::type result_type; + + static result_type invoke( const T& t ) { + return result_type(); + } + +}; + +} // namespace detail + + +namespace result_of { + +template< typename T, typename Tag = tag::addressing_index<1> > +struct size { + BOOST_STATIC_ASSERT( (is_tag::value) ); + typedef typename detail::size_impl< T, Tag >::result_type type; +}; + +} // namespace result_of + +// +// Overloads for free template functions size( x, tag ), +// +template< typename T, typename Tag > +inline typename result_of::size< const T, Tag >::type +size( const T& t, Tag ) { + return detail::size_impl< const T, Tag >::invoke( t ); +} + +// Overloads for free template function size( x ) +// Valid for types with rank <= 1 (scalars, vectors) +// In theory, we could provide overloads for matrices here, too, +// if their minimal_rank is at most 1. + +template< typename T > +typename boost::enable_if< mpl::less< rank, mpl::int_<2> >, + typename result_of::size< const T >::type >::type +size( const T& t ) { + return detail::size_impl< const T, tag::addressing_index<1> >::invoke( t ); +} + +#define GENERATE_SIZE_INDEX( z, which, unused ) \ +GENERATE_FUNCTIONS( size, which, tag::addressing_index ) + +BOOST_PP_REPEAT_FROM_TO(1,3,GENERATE_SIZE_INDEX,~) + +GENERATE_FUNCTIONS( size, _row, tag::addressing_index<1> ) +GENERATE_FUNCTIONS( size, _column, tag::addressing_index<2> ) +GENERATE_FUNCTIONS( size, _major, typename addressing_index_major::type ) +GENERATE_FUNCTIONS( size, _minor, typename addressing_index_minor::type ) + +// +// Overloads for free template functions size_row( x, tag ), +// Here, tag is assumed to be either one of +// tag::transpose, tag::no_transpose, or tag::conjugate +// +namespace result_of { + +template< typename T, typename TransTag > +struct size_row_op { + typedef typename size< + T, + typename addressing_index_trans< tag::addressing_index<1>, TransTag >::type + >::type type; +}; + +template< typename T, typename TransTag > +struct size_column_op { + typedef typename size< T, + typename addressing_index_trans< tag::addressing_index<2>, TransTag >::type >::type type; +}; + +} // namespace result_of + +template< typename T, typename Tag > +inline typename result_of::size_row_op< const T, Tag >::type +size_row_op( const T& t, Tag ) { + return bindings::size( t, typename addressing_index_trans< tag::addressing_index<1>, Tag >::type() ); +} + +template< typename T, typename Tag > +inline typename result_of::size_row_op< const T, Tag >::type +size_column_op( const T& t, Tag ) { + return bindings::size( t, typename addressing_index_trans< tag::addressing_index<2>, Tag >::type() ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/std.hpp b/sdk/boost/numeric/bindings/std.hpp new file mode 100644 index 0000000..86e1bf6 --- /dev/null +++ b/sdk/boost/numeric/bindings/std.hpp @@ -0,0 +1,15 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_STD_HPP +#define BOOST_NUMERIC_BINDINGS_STD_HPP + +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/std/valarray.hpp b/sdk/boost/numeric/bindings/std/valarray.hpp new file mode 100644 index 0000000..e919db3 --- /dev/null +++ b/sdk/boost/numeric/bindings/std/valarray.hpp @@ -0,0 +1,51 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_STD_VALARRAY_HPP +#define BOOST_NUMERIC_BINDINGS_STD_VALARRAY_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable > +struct adaptor< std::valarray< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return &const_cast< std::valarray< T >& >( id )[0]; + } + + static value_type* end_value( Id& id ) { + return &const_cast< std::valarray< T >& >( id )[0] + id.size(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/std/vector.hpp b/sdk/boost/numeric/bindings/std/vector.hpp new file mode 100644 index 0000000..484569c --- /dev/null +++ b/sdk/boost/numeric/bindings/std/vector.hpp @@ -0,0 +1,51 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_STD_VECTOR_HPP +#define BOOST_NUMERIC_BINDINGS_STD_VECTOR_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Alloc, typename Id, typename Enable > +struct adaptor< std::vector< T, Alloc >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& t ) { + return t.size(); + } + + static value_type* begin_value( Id& t ) { + return &t.front(); + } + + static value_type* end_value( Id& t ) { + return &t.front() + t.size(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/stride.hpp b/sdk/boost/numeric/bindings/stride.hpp new file mode 100644 index 0000000..f1f1a13 --- /dev/null +++ b/sdk/boost/numeric/bindings/stride.hpp @@ -0,0 +1,210 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_STRIDE_HPP +#define BOOST_NUMERIC_BINDINGS_STRIDE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename AddressingIndex, typename Enable = void > +struct stride_impl { + + typedef tag::stride_type< AddressingIndex::value > key_type; + typedef typename result_of_get< T, key_type >::type result_type; + + static result_type invoke( const T& t ) { + return get< key_type >( t ); + } + +}; + +// +// Strides for ranks outside the scope of the object are fixed at +// the dot product of its existing sizes and strides. +// +// Object rank result of strideN(), with N > rank +// scalar 0 1 +// vector 1 size1 * stride1 +// matrix 2 size1 * stride1 + size2 * stride2 +// tensor N sum_i( size_i, stride_i ) (dot( size, stride)) +// +// Iff size_i and stride_i are integral constants, results will be known at +// compile time. Otherwise, the result_type will be std::ptrdiff_t. +// +template< typename T, typename AddressingIndex > +struct stride_impl< T, AddressingIndex, + typename boost::enable_if< + mpl::equal_to< rank, tag::scalar > + >::type > { + + typedef typename mpl::int_<1> result_type; + + static result_type invoke( const T& t ) { + return result_type(); + } + +}; + + +template< typename T, typename State, typename AddressingIndex > +struct fold_stride_size { + + typedef tag::addressing_index< AddressingIndex::value > index_type; + typedef typename result_of::size< T, index_type >::type size_type; + typedef typename stride_impl< T, index_type >::result_type stride_type; + + typedef typename mpl::if_< + mpl::or_< + is_same< State, std::ptrdiff_t >, + is_same< size_type, std::ptrdiff_t >, + is_same< stride_type, std::ptrdiff_t > + >, + std::ptrdiff_t, + mpl::plus< + State, + mpl::times< + size_type, + stride_type + > + > + >::type type; + +}; + +// +// If Result isn't a ptrdiff_t, just invoke the integral constant +// and return that. Otherwise, runtime stuff is involved, so we'll +// have to evaluate sum_i( size_i, stride_i ). +// +template< typename T, typename Result, int AddressingIndex > +struct apply_fold { + static Result invoke( const T& t ) { + return Result(); + } +}; + +template< typename T, int AddressingIndex > +struct apply_fold< T, std::ptrdiff_t, AddressingIndex > { + + static std::ptrdiff_t invoke( const T& t ) { + return size( t, tag::addressing_index< AddressingIndex >() ) * + stride_impl< T, tag::addressing_index< AddressingIndex > >::invoke( t ) + + apply_fold< T, std::ptrdiff_t, AddressingIndex-1 >::invoke( t ); + } + +}; + +template< typename T > +struct apply_fold< T, std::ptrdiff_t, 0 > { + + static std::ptrdiff_t invoke( const T& ) { + return 0; + } + +}; + + +// Could be made generic for dimensions > 2, +// but not enough time right now + + +template< typename T, typename AddressingIndex > +struct stride_impl< T, AddressingIndex, + typename boost::enable_if< + mpl::and_< + mpl::greater< rank, tag::scalar >, + mpl::greater< AddressingIndex, rank > + > + >::type > { + + typedef mpl::range_c< int, 1, rank::value+1 > index_range; + typedef typename mpl::fold< + index_range, + mpl::int_< 0 >, + fold_stride_size< + T, + mpl::_1, + mpl::_2 + > + >::type result_type; + + static result_type invoke( const T& t ) { + return apply_fold< T, result_type, rank::value >::invoke( t ); + } + + +}; + +} // namespace detail + +namespace result_of { + +template< typename T, typename Tag = tag::addressing_index<1> > +struct stride { + BOOST_STATIC_ASSERT( (is_tag::value) ); + typedef typename detail::stride_impl< T, Tag >::result_type type; +}; + +} // namespace result_of + + +// +// Overloads for free template functions stride( x, tag ), +// +template< typename T, typename Tag > +inline typename result_of::stride< const T, Tag >::type +stride( const T& t, Tag ) { + return detail::stride_impl< const T, Tag >::invoke( t ); +} + +// Overloads for free template functions stride( x ) +// Valid for types with rank <= 1 (scalars, vectors) +// In theory, we could provide overloads for matrices here, too, +// if their minimal_rank is at most 1. + +template< typename T > +inline typename +boost::enable_if< + mpl::less< rank, mpl::int_<2> >, + typename result_of::stride< const T, tag::addressing_index<1> >::type +>::type +stride( const T& t ) { + return detail::stride_impl >::invoke( t ); +} + + +#define GENERATE_STRIDE_INDEX( z, which, unused ) \ +GENERATE_FUNCTIONS( stride, which, tag::addressing_index ) + +BOOST_PP_REPEAT_FROM_TO(1,3,GENERATE_STRIDE_INDEX,~) + +GENERATE_FUNCTIONS( stride, _row, tag::addressing_index<1> ) +GENERATE_FUNCTIONS( stride, _column, tag::addressing_index<2> ) +GENERATE_FUNCTIONS( stride, _major, typename addressing_index_major::type ) +GENERATE_FUNCTIONS( stride, _minor, typename addressing_index_minor::type ) + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/symm.hpp b/sdk/boost/numeric/bindings/symm.hpp new file mode 100644 index 0000000..61587c5 --- /dev/null +++ b/sdk/boost/numeric/bindings/symm.hpp @@ -0,0 +1,44 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_SYMM_HPP +#define BOOST_NUMERIC_BINDINGS_SYMM_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct symm { + typedef detail::basic_wrapper< + T, + mpl::pair< tag::matrix_type, tag::symmetric > + > type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::symm< T >::type const symm( T& underlying ) { + return typename result_of::symm< T >::type( underlying ); +} + +template< typename T > +typename result_of::symm< const T >::type const symm( const T& underlying ) { + return typename result_of::symm< const T >::type( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/tag.hpp b/sdk/boost/numeric/bindings/tag.hpp new file mode 100644 index 0000000..7e3652e --- /dev/null +++ b/sdk/boost/numeric/bindings/tag.hpp @@ -0,0 +1,126 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_TAG_HPP +#define BOOST_NUMERIC_BINDINGS_TAG_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct is_tag: mpl::bool_ {}; + +#define ADD_TAG( tag_name ) \ +\ +namespace tag { \ +struct tag_name {}; \ +} \ +\ +template<> \ +struct is_tag< tag::tag_name >: \ + mpl::bool_< true > {}; + + +#define ADD_INT_TEMPLATE_TAG( tag_name ) \ +\ +namespace tag { \ +template< int N >\ +struct tag_name: mpl::int_< N > {}; \ +} \ +template< int N > \ +struct is_tag< tag::tag_name >: mpl::bool_< true > {}; + + +#define ADD_TAG_ALIAS( tag_name, other_tag_name ) \ +\ +namespace tag { \ +struct tag_name: other_tag_name {}; \ +} \ +\ +template<> \ +struct is_tag< tag::tag_name >: \ + mpl::bool_< true > {}; + +ADD_TAG( index_type ) +ADD_TAG( value_type ) +ADD_TAG( value ) +ADD_TAG( value_transform ) + +ADD_TAG( entity ) +ADD_TAG( matrix_type ) + +ADD_TAG( data_structure ) +ADD_TAG( data_order ) +ADD_TAG( data_side ) + +ADD_INT_TEMPLATE_TAG( tensor ) +ADD_INT_TEMPLATE_TAG( size_type ) +ADD_INT_TEMPLATE_TAG( stride_type ) +ADD_INT_TEMPLATE_TAG( bandwidth_type ) +ADD_INT_TEMPLATE_TAG( addressing_index ) + +// Supported data structures +ADD_TAG( linear_array ) +ADD_TAG( triangular_array ) +ADD_TAG( band_array ) +ADD_TAG( compressed_sparse ) +ADD_TAG( coordinate_sparse ) + +ADD_TAG( structure ) +ADD_TAG( general ) +ADD_TAG( triangular ) +ADD_TAG( unit_triangular ) +ADD_TAG( symmetric ) +ADD_TAG( hermitian ) +ADD_TAG( band ) + +ADD_TAG( num_strides ) + +ADD_TAG( row_major ) +ADD_TAG( column_major ) + +ADD_TAG( upper ) +ADD_TAG( lower ) +ADD_TAG( unit_upper ) +ADD_TAG( unit_lower ) + +// BLAS Options +ADD_TAG( no_transpose ) +ADD_TAG( transpose ) +ADD_TAG( conjugate ) + +ADD_TAG( unit ) +ADD_TAG( non_unit ) +ADD_TAG( left ) +ADD_TAG( right ) +ADD_TAG( both ) + +// Sparse matrix +ADD_TAG( index_major ) +ADD_TAG( compressed_index_major ) +ADD_TAG( index_minor ) +ADD_TAG( index_base ) + +namespace tag { + +typedef tensor<0> scalar; +typedef tensor<1> vector; +typedef tensor<2> matrix; +typedef mpl::int_<1> contiguous; + +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/traits/detail/utils.hpp b/sdk/boost/numeric/bindings/traits/detail/utils.hpp new file mode 100644 index 0000000..21143f2 --- /dev/null +++ b/sdk/boost/numeric/bindings/traits/detail/utils.hpp @@ -0,0 +1,63 @@ +/* + * + * Copyright (c) Kresimir Fresl 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Author acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +#ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UTILS_HPP +#define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UTILS_HPP + +#include +#include + +namespace boost { namespace numeric { namespace bindings { namespace traits { + + namespace detail { + + // complex array => real & imaginary arrays + template + void disentangle (CIt c, CIt c_end, RIt rr, RIt ri) { + for (; c != c_end; ++c, ++rr, ++ri) { + *rr = traits::real (*c); + *ri = traits::imag (*c); + } + } + // real & imaginary arrays => complex array + template + void interlace (RIt r, RIt r_end, RIt ri, CIt c) { + typedef typename std::iterator_traits::value_type cmplx_t; +#ifdef BOOST_NUMERIC_BINDINGS_BY_THE_BOOK + for (; r != r_end; ++r, ++ri, ++c) + *c = cmplx_t (*r, *ri); +#else + typedef typename type_traits::real_type real_t; + real_t *cp = reinterpret_cast (&*c); + for (; r != r_end; ++r, ++ri) { + *cp = *r; ++cp; + *cp = *ri; ++cp; + } +#endif + } + + // converts real/complex to std::ptrdiff_t + inline std::ptrdiff_t to_int (float f) { return static_cast (f); } + inline std::ptrdiff_t to_int (double d) { return static_cast (d); } + inline std::ptrdiff_t to_int (traits::complex_f const& cf) { + return static_cast (traits::real (cf)); + } + inline std::ptrdiff_t to_int (traits::complex_d const& cd) { + return static_cast (traits::real (cd)); + } + + } + +}}}} + +#endif diff --git a/sdk/boost/numeric/bindings/traits/type.h b/sdk/boost/numeric/bindings/traits/type.h new file mode 100644 index 0000000..6de3773 --- /dev/null +++ b/sdk/boost/numeric/bindings/traits/type.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2000,2001,2002,2003 Si-Lab b.v.b.a. and Toon Knapen + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + */ + +#ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H +#define BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H + +/* + * This header defines the C types that will be mapped to + * COMPLEX and COMPLEX*16 of Fortran + */ + +#ifndef BOOST_NUMERIC_BINDINGS_USE_COMPLEX_STRUCT + +#if defined(__GNUC__) +typedef _Complex float fcomplex_t ; +typedef _Complex double dcomplex_t ; +#else +#include +typedef std::complex fcomplex_t ; +typedef std::complex dcomplex_t ; +#endif + +#else + +typedef +union { + float cmplx[2] ; + double align_struct_ ; +} fcomplex_t ; + +typedef +struct { + double cmplx[2] ; +} dcomplex_t ; + +#endif /* BOOST_NUMERIC_BINDINGS_USE_COMPLEX_STRUCT */ + +#endif /* BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H */ diff --git a/sdk/boost/numeric/bindings/traits/type.hpp b/sdk/boost/numeric/bindings/traits/type.hpp new file mode 100644 index 0000000..073b924 --- /dev/null +++ b/sdk/boost/numeric/bindings/traits/type.hpp @@ -0,0 +1,34 @@ +#ifndef boost_numeric_bindings_type_hpp +#define boost_numeric_bindings_type_hpp + +// This header provides typedefs to float complex and double complex. +// This makes it possible to redefine the complex class being used. + +#include + +namespace boost { namespace numeric { namespace bindings { namespace traits { + + /* The types for single and double precision complex numbers. + * You can use your own types if you define + * BOOST_NUMERIC_BINDINGS_USE_CUSTOM_COMPLEX_TYPE. + * Note that these types must have the same memory layout as the + * corresponding FORTRAN types. + * For that reason you can even use a different type in each translation + * unit and the resulting binary will still work! + */ +#ifndef BOOST_NUMERIC_BINDINGS_USE_CUSTOM_COMPLEX_TYPE + typedef std::complex< float > complex_f ; + typedef std::complex< double > complex_d ; +#endif + + template + T real (std::complex const& c) { return std::real (c); } + template + T imag (std::complex const& c) { return std::imag (c); } + + + struct null_t {}; + +}}}} + +#endif // boost_numeric_bindings_type_hpp diff --git a/sdk/boost/numeric/bindings/traits/type_traits.hpp b/sdk/boost/numeric/bindings/traits/type_traits.hpp new file mode 100644 index 0000000..edd3cd2 --- /dev/null +++ b/sdk/boost/numeric/bindings/traits/type_traits.hpp @@ -0,0 +1,64 @@ +/* + * + * Copyright (c) Kresimir Fresl and Toon Knapen 2002, 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * First author acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +#ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP +#define BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP + +#include +#include + +namespace boost { namespace numeric { namespace bindings { namespace traits { + + template + struct type_traits { + }; + template<> + struct type_traits { + typedef float type; + typedef float real_type; + }; + template<> + struct type_traits { + typedef double type; + typedef double real_type; + }; + template<> + struct type_traits { + typedef complex_f type; + typedef float real_type; + }; + template<> + struct type_traits { + typedef complex_d type; + typedef double real_type; + }; + + + inline const fcomplex_t* complex_ptr(const complex_f* c) { return reinterpret_cast( c ) ; } + inline const dcomplex_t* complex_ptr(const complex_d* c) { return reinterpret_cast( c ) ; } + + inline fcomplex_t* complex_ptr( complex_f* c) { return reinterpret_cast< fcomplex_t*>( c ) ; } + inline dcomplex_t* complex_ptr( complex_d* c) { return reinterpret_cast< dcomplex_t*>( c ) ; } + + template< typename Type > + inline void* void_ptr( Type* p) { return static_cast( p ); } + template< typename Type > + inline const void* void_ptr( const Type* p) { return static_cast( p ); } + + inline complex_f complex_ret(const fcomplex_t& ret) { return reinterpret_cast( ret ) ; } + inline complex_d complex_ret(const dcomplex_t& ret) { return reinterpret_cast( ret ) ; } + +}}}} + +#endif // BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP + diff --git a/sdk/boost/numeric/bindings/trans.hpp b/sdk/boost/numeric/bindings/trans.hpp new file mode 100644 index 0000000..e27151b --- /dev/null +++ b/sdk/boost/numeric/bindings/trans.hpp @@ -0,0 +1,173 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_TRANS_HPP +#define BOOST_NUMERIC_BINDINGS_TRANS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Conj > +struct trans_wrapper: reference_wrapper { + trans_wrapper( T& t ): reference_wrapper( t ) {} +}; + +// +// In case of linear storage +// +template< typename T, typename Conj, typename Id, typename Enable > +struct adaptor< trans_wrapper, Id, Enable > { + + typedef typename property_map_of< T >::type prop_of_T; + typedef typename property_insert< T, + + // upgrade to at least a matrix + mpl::pair< + tag::entity, + tag::tensor< mpl::max< tag::matrix, rank< T > >::type::value > + >, + + // size1 <-> size2 + mpl::pair< tag::size_type<1>, typename result_of::size2< T >::type >, + mpl::pair< tag::size_type<2>, typename result_of::size1< T >::type >, + + // row_major <-> column_major + mpl::pair< + tag::data_order, + typename mpl::if_< + is_column_major< T >, + tag::row_major, + tag::column_major >::type + >, + + // Conjugate transform (if passed by template argument) + Conj, + + // If T has a linear array, or has a band array + // flip strides, stride1 <-> stride2 + typename mpl::if_< mpl::or_< has_linear_array< T >, has_band_array< T > >, + mpl::pair< tag::stride_type<1>, typename result_of::stride2< T >::type >, + mpl::void_ + >::type, + typename mpl::if_< mpl::or_< has_linear_array< T >, has_band_array< T > >, + mpl::pair< tag::stride_type<2>, typename result_of::stride1< T >::type >, + mpl::void_ + >::type, + + // If T has a band array + // flip bandwidths, bandwidth1 <-> bandwidth2 + typename mpl::if_< has_band_array< T >, + mpl::pair< tag::bandwidth_type<1>, typename result_of::bandwidth2< T >::type >, + mpl::void_ + >::type, + typename mpl::if_< has_band_array< T >, + mpl::pair< tag::bandwidth_type<2>, typename result_of::bandwidth1< T >::type >, + mpl::void_ + >::type, + + // If a data_side tag is present: + // upper <-> lower + typename mpl::if_< + mpl::has_key< prop_of_T, tag::data_side >, + typename mpl::if_< + is_same< + typename mpl::at< prop_of_T, tag::data_side >::type, + tag::upper + >, + mpl::pair< tag::data_side, tag::lower >, + mpl::pair< tag::data_side, tag::upper > + >::type, + mpl::void_ + >::type + + >::type property_map; + + // Flip size1/size2 + static typename result_of::size2< T >::type size1( const Id& id ) { + return bindings::size2( id.get() ); + } + + static typename result_of::size1< T >::type size2( const Id& id ) { + return bindings::size1( id.get() ); + } + + // Value array access + static typename result_of::begin_value< T >::type begin_value( Id& id ) { + return bindings::begin_value( id.get() ); + } + + static typename result_of::end_value< T >::type end_value( Id& id ) { + return bindings::end_value( id.get() ); + } + + // Linear array storage transpose + // Flip stride1/stride2 + static typename result_of::stride2< T >::type stride1( const Id& id ) { + return bindings::stride2( id.get() ); + } + + static typename result_of::stride1< T >::type stride2( const Id& id ) { + return bindings::stride1( id.get() ); + } + + // Banded matrix transpose + // Flip bandwidth1/bandwidth2 + static typename result_of::bandwidth2< T >::type bandwidth1( const Id& id ) { + return bindings::bandwidth2( id.get() ); + } + + static typename result_of::bandwidth1< T >::type bandwidth2( const Id& id ) { + return bindings::bandwidth1( id.get() ); + } + +}; + +} // namespace detail + +namespace result_of { + +template< typename T > +struct trans { + typedef detail::trans_wrapper type; +}; + +} + +template< typename T > +typename result_of::trans::type const trans( T& underlying ) { + return detail::trans_wrapper( underlying ); +} + +template< typename T > +typename result_of::trans::type const trans( const T& underlying ) { + return detail::trans_wrapper( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/trans_tag.hpp b/sdk/boost/numeric/bindings/trans_tag.hpp new file mode 100644 index 0000000..b63231c --- /dev/null +++ b/sdk/boost/numeric/bindings/trans_tag.hpp @@ -0,0 +1,89 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_TRANS_TAG_HPP +#define BOOST_NUMERIC_BINDINGS_TRANS_TAG_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename LibraryOrder, typename DataOrder, typename ValueTransform > +struct trans_tag_impl { + // If your program complains about this part, this probably + // means that you are trying to use row_major matrices where you + // should use column_major matrices. E.g., for ublas, use + // matrix< double, column_major > instead of matrix< double > + // to fix this. +}; + +template<> +struct trans_tag_impl< tag::column_major, tag::column_major, mpl::void_ > { + typedef tag::no_transpose type; +}; + +template<> +struct trans_tag_impl< tag::column_major, tag::row_major, mpl::void_ > { + typedef tag::transpose type; +}; + +template<> +struct trans_tag_impl< tag::column_major, tag::row_major, tag::conjugate > { + typedef tag::conjugate type; +}; + +template<> +struct trans_tag_impl< tag::row_major, tag::row_major, mpl::void_ > { + typedef tag::no_transpose type; +}; + +template<> +struct trans_tag_impl< tag::row_major, tag::column_major, mpl::void_ > { + typedef tag::transpose type; +}; + +template<> +struct trans_tag_impl< tag::row_major, tag::column_major, tag::conjugate > { + typedef tag::conjugate type; +}; + +} // namespace detail + +namespace result_of { + +template< typename T, typename Order > +struct trans_tag { + typedef typename detail::trans_tag_impl< Order, + typename result_of::data_order::type, + typename detail::property_at< T, tag::value_transform >::type >::type type; +}; + +} // namespace result_of + +// +// trans_tag will output tags that are compatible with BLAS and LAPACK, either one +// of tag::transpose, tag::no_transpose, or tag::conjugate. +// It needs an library-orientation (Order) before it can make a decision about whether +// a tranpose is in order. Consult the various cases above to see what kind of +// tag is being generated in what kind of situation. +// +template< typename T, typename Order > +typename result_of::trans_tag< T, Order >::type trans_tag( const T& t, Order ) { + return result_of::trans_tag< T, Order >::type(); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas.hpp b/sdk/boost/numeric/bindings/ublas.hpp new file mode 100644 index 0000000..a58b6ed --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas.hpp @@ -0,0 +1,27 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/banded.hpp b/sdk/boost/numeric/bindings/ublas/banded.hpp new file mode 100644 index 0000000..1252836 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/banded.hpp @@ -0,0 +1,121 @@ +// +// Copyright (c) 2002 Kresimir Fresl +// Copyright (c) 2010 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_BANDED_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_BANDED_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename F, typename A, typename Id, typename Enable > +struct adaptor< ublas::banded_matrix< T, F, A >, Id, Enable > { + + // The ublas banded row_major format corresponds to the LAPACK band format. + // LAPACK is column_major; so we flip the data order reported by uBLAS. + typedef typename copy_const< Id, T >::type value_type; + typedef typename if_row_major< + typename convert_to< tag::data_order, F >::type, + tag::column_major, + tag::row_major + >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::band >, + mpl::pair< tag::data_structure, tag::band_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::bandwidth_type<1>, std::ptrdiff_t >, + mpl::pair< tag::bandwidth_type<2>, std::ptrdiff_t >, + mpl::pair< tag::stride_type<1>, + typename if_row_major< data_order, std::ptrdiff_t, tag::contiguous >::type >, + mpl::pair< tag::stride_type<2>, + typename if_row_major< data_order, tag::contiguous, std::ptrdiff_t >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + + // A.k.a. left half-bandwidth + static std::ptrdiff_t bandwidth1( const Id& id ) { + return id.lower(); + } + + // A.k.a. right half-bandwidth + static std::ptrdiff_t bandwidth2( const Id& id ) { + return id.upper(); + } + + // These strides are over the band array structure; not over + // the band matrix representation of this structure + static std::ptrdiff_t stride1( const Id& id ) { + return id.lower() + id.upper() + 1; + } + + static std::ptrdiff_t stride2( const Id& id ) { + return id.lower() + id.upper() + 1; + } + +}; + + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::banded_adaptor< T >, Id, Enable >: + basic_ublas_adaptor< + T, + Id, + mpl::pair< tag::matrix_type, tag::band >, + mpl::pair< tag::bandwidth_type<1>, std::ptrdiff_t >, + mpl::pair< tag::bandwidth_type<2>, std::ptrdiff_t > + > { + + // A.k.a. left half-bandwidth + static std::ptrdiff_t bandwidth1( const Id& id ) { + return id.lower(); + } + + // A.k.a. right half-bandwidth + static std::ptrdiff_t bandwidth2( const Id& id ) { + return id.upper(); + } + +}; + +} // detail +} // bindings +} // numeric +} // boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/detail/basic_ublas_adaptor.hpp b/sdk/boost/numeric/bindings/ublas/detail/basic_ublas_adaptor.hpp new file mode 100644 index 0000000..f51e2ef --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/detail/basic_ublas_adaptor.hpp @@ -0,0 +1,60 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_DETAIL_BASIC_UBLAS_ADAPTOR_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_DETAIL_BASIC_UBLAS_ADAPTOR_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename P1 = mpl::void_, + typename P2 = mpl::void_, typename P3 = mpl::void_ > +struct basic_ublas_adaptor { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_insert< adapted_type, P1, P2, P3 >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.data() ); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return bindings::stride2( id.data() ); + } + +}; + +} // detail +} // bindings +} // numeric +} // boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/detail/convert_to.hpp b/sdk/boost/numeric/bindings/ublas/detail/convert_to.hpp new file mode 100644 index 0000000..e3331e8 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/detail/convert_to.hpp @@ -0,0 +1,76 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_DETAIL_CONVERT_TO_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_DETAIL_CONVERT_TO_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template<> +struct convert_to< tag::data_order, ublas::row_major > { + typedef tag::row_major type; +}; + +template<> +struct convert_to< tag::data_order, ublas::column_major > { + typedef tag::column_major type; +}; + +template<> +struct convert_to< tag::matrix_type, ublas::lower > { + typedef tag::triangular type; +}; + +template<> +struct convert_to< tag::matrix_type, ublas::upper > { + typedef tag::triangular type; +}; + +template<> +struct convert_to< tag::matrix_type, ublas::unit_lower > { + typedef tag::unit_triangular type; +}; + +template<> +struct convert_to< tag::matrix_type, ublas::unit_upper > { + typedef tag::unit_triangular type; +}; + +template<> +struct convert_to< tag::data_side, ublas::lower > { + typedef tag::lower type; +}; + +template<> +struct convert_to< tag::data_side, ublas::upper > { + typedef tag::upper type; +}; + +template<> +struct convert_to< tag::data_side, ublas::unit_lower > { + typedef tag::lower type; +}; + +template<> +struct convert_to< tag::data_side, ublas::unit_upper > { + typedef tag::upper type; +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/hermitian.hpp b/sdk/boost/numeric/bindings/ublas/hermitian.hpp new file mode 100644 index 0000000..9395eaf --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/hermitian.hpp @@ -0,0 +1,86 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_HERMITIAN_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_HERMITIAN_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename F1, typename F2, typename A, typename Id, typename Enable > +struct adaptor< ublas::hermitian_matrix< T, F1, F2, A >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::hermitian >, + mpl::pair< tag::data_structure, tag::triangular_array >, + mpl::pair< tag::data_side, typename convert_to< tag::data_side, F1 >::type >, + mpl::pair< tag::data_order, typename convert_to< tag::data_order, F2 >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + +}; + +template< typename T, typename F, typename Id, typename Enable > +struct adaptor< ublas::hermitian_adaptor< T, F >, Id, Enable >: + basic_ublas_adaptor< + T, + Id, + mpl::pair< tag::matrix_type, tag::hermitian >, + mpl::pair< tag::data_side, typename convert_to< tag::data_side, F >::type > + > { + + typedef typename convert_to< tag::data_side, F >::type data_side; + + static std::ptrdiff_t bandwidth1( const Id& id ) { + return bindings::bandwidth( id.data(), data_side() ); + } + + static std::ptrdiff_t bandwidth2( const Id& id ) { + return bindings::bandwidth( id.data(), data_side() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/matrix.hpp b/sdk/boost/numeric/bindings/ublas/matrix.hpp new file mode 100644 index 0000000..bcf71aa --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/matrix.hpp @@ -0,0 +1,148 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename F, typename A, typename Id, typename Enable > +struct adaptor< ::boost::numeric::ublas::matrix< T, F, A >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename convert_to< tag::data_order, F >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::stride_type<1>, + typename if_row_major< data_order, std::ptrdiff_t, tag::contiguous >::type >, + mpl::pair< tag::stride_type<2>, + typename if_row_major< data_order, tag::contiguous, std::ptrdiff_t >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.size2(); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return id.size1(); + } + +}; + +template< typename T, std::size_t M, std::size_t N, typename F, typename Id, typename Enable > +struct adaptor< ::boost::numeric::ublas::bounded_matrix< T, M, N, F >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename convert_to< tag::data_order, F >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::stride_type<1>, + typename if_row_major< data_order, mpl::int_, tag::contiguous >::type >, + mpl::pair< tag::stride_type<2>, + typename if_row_major< data_order, tag::contiguous, mpl::int_ >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + +}; + +template< typename T, std::size_t M, std::size_t N, typename Id, typename Enable > +struct adaptor< ::boost::numeric::ublas::c_matrix< T, M, N >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::data_order, tag::row_major >, + mpl::pair< tag::stride_type<1>, mpl::int_ >, + mpl::pair< tag::stride_type<2>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return id.data(); + } + + static value_type* end_value( Id& id ) { + return id.data() + offset( id, id.size1(), id.size2() ); + } + +}; + + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/matrix_expression.hpp b/sdk/boost/numeric/bindings/ublas/matrix_expression.hpp new file mode 100644 index 0000000..6d07dc7 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/matrix_expression.hpp @@ -0,0 +1,126 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_EXPRESSION_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_EXPRESSION_HPP + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable > +struct adaptor< boost::numeric::ublas::matrix_reference< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.expression() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::end_value( id.expression() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.expression() ); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return bindings::stride2( id.expression() ); + } + + static std::ptrdiff_t bandwidth1( const Id& id ) { + return bindings::bandwidth1( id.expression() ); + } + + static std::ptrdiff_t bandwidth2( const Id& id ) { + return bindings::bandwidth2( id.expression() ); + } + +}; + +template< typename T, typename U, typename Id, typename Enable > +struct adaptor< boost::numeric::ublas::matrix_unary2< T, U >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type map; + + typedef mpl::map< + mpl::pair::type>, + mpl::pair::type>, + mpl::pair, typename mpl::at >::type>, + mpl::pair, typename mpl::at >::type>, + mpl::pair::type>, + + mpl::pair::type, + tag::row_major>, + tag::column_major, + tag::row_major + >::type>, + + mpl::pair, typename mpl::at >:: type>, + mpl::pair, typename mpl::at >:: type> + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static typename result_of::begin_value< adapted_type >::type + begin_value( Id& id ) { + return bindings::begin_value( id.expression() ); + } + + static typename result_of::end_value< adapted_type >::type + end_value( Id& id ) { + return bindings::end_value( id.expression() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride2( id.expression() ); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return bindings::stride1( id.expression() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/matrix_proxy.hpp b/sdk/boost/numeric/bindings/ublas/matrix_proxy.hpp new file mode 100644 index 0000000..eb5e010 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/matrix_proxy.hpp @@ -0,0 +1,244 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_PROXY_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_PROXY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::matrix_range< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1(), id.start2() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1() + id.size1(), id.start2() + id.size2() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.data() ); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return bindings::stride2( id.data() ); + } + + static std::ptrdiff_t bandwidth1( const Id& id ) { + return bindings::bandwidth1( id.data() ); + } + + static std::ptrdiff_t bandwidth2( const Id& id ) { + return bindings::bandwidth2( id.data() ); + } + +}; + + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::matrix_slice< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1(), id.start2() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1() + id.size1(), id.start2() + id.size2() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.stride1(); + } + + static std::ptrdiff_t stride2( const Id& id ) { + return id.stride2(); + } + + static std::ptrdiff_t bandwidth1( const Id& id ) { + return bindings::bandwidth1( id.data() ); + } + + static std::ptrdiff_t bandwidth2( const Id& id ) { + return bindings::bandwidth2( id.data() ); + } + +}; + + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::matrix_column< T >, Id, Enable > { + + typedef typename copy_const< Id, typename bindings::value_type< T>::type >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + // TODO in case of column major, this could be contiguous + mpl::pair< tag::stride_type<1>, std::ptrdiff_t > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), 0, id.index() ); + } + + static value_type* end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), bindings::size(id), id.index() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.data() ); + } + +}; + + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::matrix_row< T >, Id, Enable > { + + typedef typename copy_const< Id, typename bindings::value_type< T>::type >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + // TODO in case of row major, this could be contiguous + mpl::pair< tag::stride_type<1>, std::ptrdiff_t > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.index(), 0 ); + } + + static value_type* end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.index(), bindings::size(id) ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride2( id.data() ); + } + +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::matrix_vector_range< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_insert< adapted_type, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::stride_type<1>, std::ptrdiff_t > + >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1(), id.start2() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1() + id.size1(), id.start2() + id.size2() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.data() ) + bindings::stride2( id.data() ); + } + +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::matrix_vector_slice< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_insert< adapted_type, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::stride_type<1>, std::ptrdiff_t > + >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1(), id.start2() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id.data(), id.start1() + id.size1(), id.start2() + id.size2() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return id.stride1() * bindings::stride1( id.data() ) + + id.stride2() * bindings::stride2( id.data() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/matrix_sparse.hpp b/sdk/boost/numeric/bindings/ublas/matrix_sparse.hpp new file mode 100644 index 0000000..1701220 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/matrix_sparse.hpp @@ -0,0 +1,135 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_SPARSE_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_MATRIX_SPARSE_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename F, std::size_t IB, typename IA, typename TA, typename Id, typename Enable > +struct adaptor< ublas::compressed_matrix< T, F, IB, IA, TA >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename copy_const< Id, typename bindings::value_type::type >::type index_type; + typedef typename convert_to< tag::data_order, F >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::index_type, index_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::compressed_sparse >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::index_base, mpl::int_ > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.value_data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::begin_value( id.value_data() ) + id.nnz(); + } + + static index_type* begin_compressed_index_major( Id& id ) { + return bindings::begin_value( id.index1_data() ); + } + + static index_type* end_compressed_index_major( Id& id ) { + return bindings::end_value( id.index1_data() ); + } + + static index_type* begin_index_minor( Id& id ) { + return bindings::begin_value( id.index2_data() ); + } + + static index_type* end_index_minor( Id& id ) { + return bindings::begin_value( id.index2_data() ) + id.nnz(); + } + +}; + +template< typename T, typename F, std::size_t IB, typename IA, typename TA, typename Id, typename Enable > +struct adaptor< ublas::coordinate_matrix< T, F, IB, IA, TA >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef typename copy_const< Id, typename bindings::value_type::type >::type index_type; + typedef typename convert_to< tag::data_order, F >::type data_order; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::index_type, index_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::general >, + mpl::pair< tag::data_structure, tag::coordinate_sparse >, + mpl::pair< tag::data_order, data_order >, + mpl::pair< tag::index_base, mpl::int_ > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size1(); + } + + static std::ptrdiff_t size2( const Id& id ) { + return id.size2(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.value_data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::begin_value( id.value_data() ) + id.nnz(); + } + + static index_type* begin_index_major( Id& id ) { + return bindings::begin_value( id.index1_data() ); + } + + static index_type* end_index_major( Id& id ) { + return bindings::begin_value( id.index1_data() ) + id.nnz(); + } + + static index_type* begin_index_minor( Id& id ) { + return bindings::begin_value( id.index2_data() ); + } + + static index_type* end_index_minor( Id& id ) { + return bindings::begin_value( id.index2_data() ) + id.nnz(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/scalar_vector.hpp b/sdk/boost/numeric/bindings/ublas/scalar_vector.hpp new file mode 100644 index 0000000..d454c18 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/scalar_vector.hpp @@ -0,0 +1,51 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_SCALAR_VECTOR_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_SCALAR_VECTOR_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Alloc, typename Id, typename Enable > +struct adaptor< ublas::scalar_vector< T, Alloc >, Id, Enable > { + + typedef typename add_const< T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, mpl::int_<0> > + > property_map; + + static std::ptrdiff_t size1( const Id& t ) { + return t.size(); + } + + static value_type* begin_value( Id& t ) { + return t.find_element( 0 ); + } + + static value_type* end_value( Id& t ) { + return t.find_element( 0 ) + 1; + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/storage.hpp b/sdk/boost/numeric/bindings/ublas/storage.hpp new file mode 100644 index 0000000..dfdc1bd --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/storage.hpp @@ -0,0 +1,53 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// Copyright (c) 2011 Andrey Asadchev +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_STORAGE_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_STORAGE_HPP + +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id > +struct adaptor< T, Id, typename boost::enable_if< boost::is_base_of< ublas::storage_array, T> >::type > { + + typedef typename copy_const< Id, typename T::value_type >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return id.begin(); + } + + static value_type* end_value( Id& id ) { + return id.end(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/symmetric.hpp b/sdk/boost/numeric/bindings/ublas/symmetric.hpp new file mode 100644 index 0000000..1d3f64e --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/symmetric.hpp @@ -0,0 +1,86 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_SYMMETRIC_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_SYMMETRIC_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename F1, typename F2, typename A, typename Id, typename Enable > +struct adaptor< ublas::symmetric_matrix< T, F1, F2, A >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, tag::symmetric >, + mpl::pair< tag::data_structure, tag::triangular_array >, + mpl::pair< tag::data_side, typename convert_to< tag::data_side, F1 >::type >, + mpl::pair< tag::data_order, typename convert_to< tag::data_order, F2 >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& t ) { + return t.size1(); + } + + static std::ptrdiff_t size2( const Id& t ) { + return t.size2(); + } + + static value_type* begin_value( Id& t ) { + return bindings::begin_value( t.data() ); + } + + static value_type* end_value( Id& t ) { + return bindings::end_value( t.data() ); + } + +}; + +template< typename T, typename F, typename Id, typename Enable > +struct adaptor< ublas::symmetric_adaptor< T, F >, Id, Enable >: + basic_ublas_adaptor< + T, + Id, + mpl::pair< tag::matrix_type, tag::symmetric >, + mpl::pair< tag::data_side, typename convert_to< tag::data_side, F >::type > + > { + + typedef typename convert_to< tag::data_side, F >::type data_side; + + static std::ptrdiff_t bandwidth1( const Id& id ) { + return bindings::bandwidth( id.data(), data_side() ); + } + + static std::ptrdiff_t bandwidth2( const Id& id ) { + return bindings::bandwidth( id.data(), data_side() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/triangular.hpp b/sdk/boost/numeric/bindings/ublas/triangular.hpp new file mode 100644 index 0000000..66bb3fd --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/triangular.hpp @@ -0,0 +1,73 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_TRIANGULAR_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_TRIANGULAR_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename F1, typename F2, typename A, typename Id, typename Enable > +struct adaptor< ublas::triangular_matrix< T, F1, F2, A >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::matrix >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::size_type<2>, std::ptrdiff_t >, + mpl::pair< tag::matrix_type, typename convert_to< tag::matrix_type, F1 >::type >, + mpl::pair< tag::data_structure, tag::triangular_array >, + mpl::pair< tag::data_side, typename convert_to< tag::data_side, F1 >::type >, + mpl::pair< tag::data_order, typename convert_to< tag::data_order, F2 >::type > + > property_map; + + static std::ptrdiff_t size1( const Id& t ) { + return t.size1(); + } + + static std::ptrdiff_t size2( const Id& t ) { + return t.size2(); + } + + static value_type* begin_value( Id& t ) { + return bindings::begin_value( t.data() ); + } + + static value_type* end_value( Id& t ) { + return bindings::end_value( t.data() ); + } + +}; + +template< typename T, typename F, typename Id, typename Enable > +struct adaptor< ublas::triangular_adaptor< T, F >, Id, Enable >: + basic_ublas_adaptor< + T, + Id, + mpl::pair< tag::matrix_type, typename convert_to< tag::matrix_type, F >::type >, + mpl::pair< tag::data_side, typename convert_to< tag::data_side, F >::type > + > {}; + +} // detail +} // bindings +} // numeric +} // boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/vector.hpp b/sdk/boost/numeric/bindings/ublas/vector.hpp new file mode 100644 index 0000000..b278268 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/vector.hpp @@ -0,0 +1,107 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_HPP + +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Alloc, typename Id, typename Enable > +struct adaptor< ublas::vector< T, Alloc >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + +}; + +template< typename T, std::size_t N, typename Id, typename Enable > +struct adaptor< ublas::bounded_vector< T, N >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return bindings::begin_value( id.data() ); + } + + static value_type* end_value( Id& id ) { + return bindings::end_value( id.data() ); + } + +}; + +template< typename T, std::size_t N, typename Id, typename Enable > +struct adaptor< ublas::c_vector< T, N >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static value_type* begin_value( Id& id ) { + return id.data(); + } + + static value_type* end_value( Id& id ) { + return id.data() + id.size(); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/vector_expression.hpp b/sdk/boost/numeric/bindings/ublas/vector_expression.hpp new file mode 100644 index 0000000..7c89f22 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/vector_expression.hpp @@ -0,0 +1,54 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_EXPRESSION_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_EXPRESSION_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::vector_reference< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.expression() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::end_value( id.expression() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.expression() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/vector_proxy.hpp b/sdk/boost/numeric/bindings/ublas/vector_proxy.hpp new file mode 100644 index 0000000..fadbdd4 --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/vector_proxy.hpp @@ -0,0 +1,81 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_PROXY_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_PROXY_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::vector_range< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + id.start() * stride1( id ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::begin_value( id.data() ) + id.size() * stride1( id ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.data() ); + } + +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< ublas::vector_slice< T >, Id, Enable > { + + typedef typename copy_const< Id, T >::type adapted_type; + typedef typename property_map_of< adapted_type >::type property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.size(); + } + + static typename result_of::begin_value< adapted_type >::type begin_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id, id.start() ); + } + + static typename result_of::end_value< adapted_type >::type end_value( Id& id ) { + return bindings::begin_value( id.data() ) + + offset( id, id.start() + id.size() ); + } + + static std::ptrdiff_t stride1( const Id& id ) { + return bindings::stride1( id.data() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/ublas/vector_sparse.hpp b/sdk/boost/numeric/bindings/ublas/vector_sparse.hpp new file mode 100644 index 0000000..60ad5ca --- /dev/null +++ b/sdk/boost/numeric/bindings/ublas/vector_sparse.hpp @@ -0,0 +1,53 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_SPARSE_HPP +#define BOOST_NUMERIC_BINDINGS_UBLAS_VECTOR_SPARSE_HPP + +#include +#include +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T, std::size_t IB, typename IA, typename TA, typename Id, typename Enable > +struct adaptor< ublas::compressed_vector< T, IB, IA, TA >, Id, Enable > { + + typedef typename copy_const< Id, T >::type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::compressed_sparse > + > property_map; + + static std::ptrdiff_t size1( const Id& t ) { + return t.size(); + } + +// static void index_data( Id& t ) { +// // t.index_data(); +// } +// + + static value_type* begin_value( Id& t ) { + return bindings::begin_value( t.value_data() ); + } + +}; + +} // namespace detail +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/umfpack/umfpack.hpp b/sdk/boost/numeric/bindings/umfpack/umfpack.hpp new file mode 100644 index 0000000..47d906a --- /dev/null +++ b/sdk/boost/numeric/bindings/umfpack/umfpack.hpp @@ -0,0 +1,1053 @@ +/* + * + * Copyright (c) Kresimir Fresl 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Author acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +/* for UMFPACK Copyright, License and Availability see umfpack_inc.hpp */ + + +#ifndef BOOST_NUMERIC_BINDINGS_UMFPACK_HPP +#define BOOST_NUMERIC_BINDINGS_UMFPACK_HPP + + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace boost { namespace numeric { namespace bindings { namespace umfpack { + + template + void check_umfpack_structure() + { + BOOST_STATIC_ASSERT((boost::is_same< + typename bindings::detail::property_at< MatrA, tag::matrix_type >::type, + tag::general + >::value)); + BOOST_STATIC_ASSERT((boost::is_same< + typename bindings::result_of::data_order::type, + tag::column_major + >::value)); + typedef typename bindings::result_of::index_base::type index_b; + BOOST_STATIC_ASSERT(index_b::value == 0); + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + BOOST_STATIC_ASSERT( + (boost::is_same::value || + boost::is_same::value )); + } + + template + struct symbolic_type : private noncopyable { + void *ptr; + symbolic_type():ptr(0){} + ~symbolic_type() { + if (ptr) + detail::free_symbolic (T(), 0, &ptr); + } + void free() { + if (ptr) + detail::free_symbolic (T(), 0, &ptr); + ptr = 0; + } + }; + + template + void free (symbolic_type& s) { s.free(); } + + template + struct numeric_type : private noncopyable { + void *ptr; + numeric_type():ptr(0){} + ~numeric_type() { + if (ptr) + detail::free_numeric (T(), 0, &ptr); + } + void free() { + if (ptr) + detail::free_numeric (T(), 0, &ptr); + ptr = 0; + } + }; + + template + void free (numeric_type& n) { n.free(); } + + + template + struct control_type : private noncopyable { + double ptr[UMFPACK_CONTROL]; + control_type() { detail::defaults (T(), 0, ptr); } + double operator[] (int i) const { return ptr[i]; } + double& operator[] (int i) { return ptr[i]; } + void defaults() { detail::defaults (T(), 0, ptr); } + }; + + template + void defaults (control_type& c) { c.defaults(); } + + template + struct info_type : private noncopyable { + double ptr[UMFPACK_INFO]; + double operator[] (int i) const { return ptr[i]; } + double& operator[] (int i) { return ptr[i]; } + }; + + + ///////////////////////////////////// + // solving system of linear equations + ///////////////////////////////////// + + + // symbolic + /* + * Given nonzero pattern of a sparse matrix A in column-oriented form, + * umfpack_*_symbolic performs a column pre-ordering to reduce fill-in + * (using COLAMD or AMD) and a symbolic factorisation. This is required + * before the matrix can be numerically factorised with umfpack_*_numeric. + */ + namespace detail { + + template + inline + int symbolic (tag::compressed_sparse, + MatrA const& A, void **Symbolic, + double const* Control = 0, double* Info = 0) + { + return detail::symbolic (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + Symbolic, Control, Info); + } + + template + inline + int symbolic (tag::compressed_sparse, + MatrA const& A, QVec const& Qinit, void **Symbolic, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif + return detail::qsymbolic (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + bindings::begin_value (Qinit), + Symbolic, Control, Info); + } + + template + inline + int symbolic (tag::coordinate_sparse, + MatrA const& A, void **Symbolic, + double const* Control = 0, double* Info = 0) + { + int n_row = bindings::size_row (A); + int n_col = bindings::size_column (A); + int nnz = bindings::end_value (A) - bindings::begin_value (A); + + typedef typename bindings::value_type::type val_t; + + int const* Ti = bindings::begin_index_minor (A); + int const* Tj = bindings::begin_index_major (A); + bindings::detail::array Ap (n_col+1); + if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Ai (nnz); + if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = detail::triplet_to_col (n_row, n_col, nnz, + Ti, Tj, static_cast (0), + Ap.storage(), Ai.storage(), + static_cast (0), 0); + if (status != UMFPACK_OK) return status; + + return detail::symbolic (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + Symbolic, Control, Info); + } + + template + inline + int symbolic (tag::coordinate_sparse, + MatrA const& A, QVec const& Qinit, void **Symbolic, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif + int n_row = bindings::size_row (A); + int n_col = bindings::size_column (A); + int nnz = bindings::end_value (A) - bindings::begin_value (A); + + typedef typename bindings::value_type::type val_t; + + int const* Ti = bindings::begin_index_minor (A); + int const* Tj = bindings::begin_index_major (A); + bindings::detail::array Ap (n_col+1); + if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Ai (nnz); + if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = detail::triplet_to_col (n_row, n_col, nnz, + Ti, Tj, static_cast (0), + Ap.storage(), Ai.storage(), + static_cast (0), 0); + if (status != UMFPACK_OK) return status; + + return detail::qsymbolic (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + bindings::begin_value (Qinit), + Symbolic, Control, Info); + } + + } // detail + + template + inline + int symbolic (MatrA const& A, + symbolic_type< + typename bindings::value_type::type + >& Symbolic, + double const* Control = 0, double* Info = 0) + { +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + return detail::symbolic (storage_f(), A, &Symbolic.ptr, Control, Info); + } + + template + inline + int symbolic (MatrA const& A, + symbolic_type< + typename bindings::value_type::type + >& Symbolic, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + { + return symbolic (A, Symbolic, Control.ptr, Info.ptr); + } + + template + inline + int symbolic (MatrA const& A, + symbolic_type< + typename bindings::value_type::type + >& Symbolic, + control_type< + typename bindings::value_type::type + > const& Control) + { + return symbolic (A, Symbolic, Control.ptr); + } + + template + inline + int symbolic (MatrA const& A, QVec const& Qinit, + symbolic_type< + typename bindings::value_type::type + >& Symbolic, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + assert (bindings::size_column (A) == bindings::size (Qinit)); + + return detail::symbolic (storage_f(), A, Qinit, + &Symbolic.ptr, Control, Info); + } + + template + inline + int symbolic (MatrA const& A, QVec const& Qinit, + symbolic_type< + typename bindings::value_type::type + >& Symbolic, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + { + return symbolic (A, Qinit, Symbolic, Control.ptr, Info.ptr); + } + + template + inline + int symbolic (MatrA const& A, QVec const& Qinit, + symbolic_type< + typename bindings::value_type::type + >& Symbolic, + control_type< + typename bindings::value_type::type + > const& Control) + { + return symbolic (A, Qinit, Symbolic, Control.ptr); + } + + + // numeric + /* + * Given a sparse matrix A in column-oriented form, and a symbolic analysis + * computed by umfpack_*_*symbolic, the umfpack_*_numeric routine performs + * the numerical factorisation, PAQ=LU, PRAQ=LU, or P(R\A)Q=LU, where P + * and Q are permutation matrices (represented as permutation vectors), + * R is the row scaling, L is unit-lower triangular, and U is upper + * triangular. This is required before the system Ax=b (or other related + * linear systems) can be solved. + */ + namespace detail { + + template + inline + int numeric (tag::compressed_sparse, MatrA const& A, + void *Symbolic, void** Numeric, + double const* Control = 0, double* Info = 0) + { + return detail::numeric (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + Symbolic, Numeric, Control, Info); + } + + template + inline + int numeric (tag::coordinate_sparse, MatrA const& A, + void *Symbolic, void** Numeric, + double const* Control = 0, double* Info = 0) + { + int n_row = bindings::size_row (A); + int n_col = bindings::size_column (A); + int nnz = bindings::end_value (A) - bindings::begin_value (A); + + typedef typename bindings::value_type::type val_t; + + int const* Ti = bindings::begin_index_minor (A); + int const* Tj = bindings::begin_index_major (A); + bindings::detail::array Ap (n_col+1); + if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Ai (nnz); + if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = detail::triplet_to_col (n_row, n_col, nnz, + Ti, Tj, static_cast (0), + Ap.storage(), Ai.storage(), + static_cast (0), 0); + if (status != UMFPACK_OK) return status; + + return detail::numeric (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + Symbolic, Numeric, Control, Info); + } + + } // detail + + template + inline + int numeric (MatrA const& A, + symbolic_type< + typename bindings::value_type::type + > const& Symbolic, + numeric_type< + typename bindings::value_type::type + >& Numeric, + double const* Control = 0, double* Info = 0) + { +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + return detail::numeric (storage_f(), A, + Symbolic.ptr, &Numeric.ptr, Control, Info); + } + + template + inline + int numeric (MatrA const& A, + symbolic_type< + typename bindings::value_type::type + > const& Symbolic, + numeric_type< + typename bindings::value_type::type + >& Numeric, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + + { + // g++ (3.2) is unable to distinguish + // function numeric() and namespace boost::numeric ;o) + return umfpack::numeric (A, Symbolic, Numeric, Control.ptr, Info.ptr); + } + + template + inline + int numeric (MatrA const& A, + symbolic_type< + typename bindings::value_type::type + > const& Symbolic, + numeric_type< + typename bindings::value_type::type + >& Numeric, + control_type< + typename bindings::value_type::type + > const& Control) + { + return umfpack::numeric (A, Symbolic, Numeric, Control.ptr); + } + + + // factor + /* + * symbolic and numeric + */ + namespace detail { + + template + inline + int factor (tag::compressed_sparse, MatrA const& A, + void** Numeric, double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif + symbolic_type::type> + Symbolic; + + int status; + status = detail::symbolic (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + &Symbolic.ptr, Control, Info); + if (status != UMFPACK_OK) return status; + + return detail::numeric (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + Symbolic.ptr, Numeric, Control, Info); + } + + template + inline + int factor (tag::coordinate_sparse, MatrA const& A, + void** Numeric, double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif + int n_row = bindings::size_row (A); + int n_col = bindings::size_column (A); + int nnz = bindings::end_value (A) - bindings::begin_value (A); + + typedef typename bindings::value_type::type val_t; + + int const* Ti = bindings::begin_index_minor (A); + int const* Tj = bindings::begin_index_major (A); + bindings::detail::array Ap (n_col+1); + if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Ai (nnz); + if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = detail::triplet_to_col (n_row, n_col, nnz, + Ti, Tj, static_cast (0), + Ap.storage(), Ai.storage(), + static_cast (0), 0); + if (status != UMFPACK_OK) return status; + + symbolic_type::type> + Symbolic; + + status = detail::symbolic (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + &Symbolic.ptr, Control, Info); + if (status != UMFPACK_OK) return status; + + return detail::numeric (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + Symbolic.ptr, Numeric, Control, Info); + } + + } // detail + + template + inline + int factor (MatrA const& A, + numeric_type< + typename bindings::value_type::type + >& Numeric, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + return detail::factor (storage_f(), A, &Numeric.ptr, Control, Info); + } + + template + inline + int factor (MatrA const& A, + numeric_type< + typename bindings::value_type::type + >& Numeric, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + { + return factor (A, Numeric, Control.ptr, Info.ptr); + } + + template + inline + int factor (MatrA const& A, + numeric_type< + typename bindings::value_type::type + >& Numeric, + control_type< + typename bindings::value_type::type + > const& Control) + { + return factor (A, Numeric, Control.ptr); + } + + + // solve + /* + * Given LU factors computed by umfpack_*_numeric and the right-hand-side, + * B, solve a linear system for the solution X. Iterative refinement is + * optionally performed. Only square systems are handled. + */ + namespace detail { + + template + inline + int solve (tag::compressed_sparse, int sys, + MatrA const& A, VecX& X, VecB const& B, + void *Numeric, double const* Control = 0, double* Info = 0) + { + return detail::solve (sys, bindings::size_row (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + bindings::begin_value (X), + bindings::begin_value (B), + Numeric, Control, Info); + } + + template + inline + int solve (tag::coordinate_sparse, int sys, + MatrA const& A, VecX& X, VecB const& B, + void *Numeric, double const* Control = 0, double* Info = 0) + { + + int n = bindings::size_row (A); + int nnz = bindings::end_value (A) - bindings::begin_value (A); + + typedef typename bindings::value_type::type val_t; + + int const* Ti = bindings::begin_index_minor (A); + int const* Tj = bindings::begin_index_major (A); + bindings::detail::array Ap (n+1); + if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Ai (nnz); + if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = detail::triplet_to_col (n, n, nnz, + Ti, Tj, static_cast (0), + Ap.storage(), Ai.storage(), + static_cast (0), 0); + if (status != UMFPACK_OK) return status; + + return detail::solve (sys, n, Ap.storage(), Ai.storage(), + bindings::begin_value (A), + bindings::begin_value (X), + bindings::begin_value (B), + Numeric, Control, Info); + } + + } // detail + + template + inline + int solve (int sys, MatrA const& A, VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric, + double const* Control = 0, double* Info = 0) + { +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + assert (bindings::size_row (A) == bindings::size_row (A)); + assert (bindings::size_column (A) == bindings::size (X)); + assert (bindings::size_column (A) == bindings::size (B)); + + return detail::solve (storage_f(), sys, A, X, B, + Numeric.ptr, Control, Info); + } + + template + inline + int solve (int sys, MatrA const& A, VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + { + return solve (sys, A, X, B, Numeric, Control.ptr, Info.ptr); + } + + template + inline + int solve (int sys, MatrA const& A, VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric, + control_type< + typename bindings::value_type::type + > const& Control) + { + return solve (sys, A, X, B, Numeric, Control.ptr); + } + + template + inline + int solve (MatrA const& A, VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric, + double const* Control = 0, double* Info = 0) + { + return solve (UMFPACK_A, A, X, B, Numeric, Control, Info); + } + + template + inline + int solve (MatrA const& A, VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + { + return solve (UMFPACK_A, A, X, B, Numeric, + Control.ptr, Info.ptr); + } + + template + inline + int solve (MatrA const& A, VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric, + control_type< + typename bindings::value_type::type + > const& Control) + { + return solve (UMFPACK_A, A, X, B, Numeric, Control.ptr); + } + + + // umf_solve + /* + * symbolic, numeric and solve + */ + namespace detail { + + template + inline + int umf_solve (tag::compressed_sparse, + MatrA const& A, VecX& X, VecB const& B, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif + symbolic_type::type> + Symbolic; + numeric_type::type> + Numeric; + + int status; + status = detail::symbolic (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + &Symbolic.ptr, Control, Info); + if (status != UMFPACK_OK) return status; + + status = detail::numeric (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + Symbolic.ptr, &Numeric.ptr, Control, Info); + if (status != UMFPACK_OK) return status; + + return detail::solve (UMFPACK_A, bindings::size_row (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + bindings::begin_value (X), + bindings::begin_value (B), + Numeric.ptr, Control, Info); + } + + template + inline + int umf_solve (tag::coordinate_sparse, + MatrA const& A, VecX& X, VecB const& B, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrAA::not_yet_tested i_m_still_here; +#endif + int n_row = bindings::size_row (A); + int n_col = bindings::size_column (A); + int nnz = bindings::end_value (A) - bindings::begin_value (A); + + typedef typename bindings::value_type::type val_t; + + int const* Ti = bindings::begin_index_minor (A); + int const* Tj = bindings::begin_index_major (A); + bindings::detail::array Ap (n_col+1); + if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Ai (nnz); + if (!Ai.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = detail::triplet_to_col (n_row, n_col, nnz, + Ti, Tj, static_cast (0), + Ap.storage(), Ai.storage(), + static_cast (0), 0); + if (status != UMFPACK_OK) return status; + + symbolic_type::type> + Symbolic; + numeric_type::type> + Numeric; + + status = detail::symbolic (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + &Symbolic.ptr, Control, Info); + if (status != UMFPACK_OK) return status; + + status = detail::numeric (n_row, n_col, + Ap.storage(), Ai.storage(), + bindings::begin_value (A), + Symbolic.ptr, &Numeric.ptr, Control, Info); + if (status != UMFPACK_OK) return status; + + return detail::solve (UMFPACK_A, n_row, Ap.storage(), Ai.storage(), + bindings::begin_value (A), + bindings::begin_value (X), + bindings::begin_value (B), + Numeric.ptr, Control, Info); + } + + } // detail + + template + inline + int umf_solve (MatrA const& A, VecX& X, VecB const& B, + double const* Control = 0, double* Info = 0) + { +#ifdef CHECK_TEST_COVERAGE + typedef typename MatrA::not_yet_tested i_m_still_here; +#endif +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + assert (bindings::size_row (A) == bindings::size_row (A)); + assert (bindings::size_column (A) == bindings::size (X)); + assert (bindings::size_column (A) == bindings::size (B)); + + return detail::umf_solve (storage_f(), A, X, B, Control, Info); + } + + template + inline + int umf_solve (MatrA const& A, VecX& X, VecB const& B, + control_type< + typename bindings::value_type::type + > const& Control, + info_type< + typename bindings::value_type::type + >& Info) + { + return umf_solve (A, X, B, Control.ptr, Info.ptr); + } + + template + inline + int umf_solve (MatrA const& A, VecX& X, VecB const& B, + control_type< + typename bindings::value_type::type + > const& Control) + { + return umf_solve (A, X, B, Control.ptr); + } + + + /////////////////////// + // matrix manipulations + /////////////////////// + + + // scale + + template + inline + int scale (VecX& X, VecB const& B, + numeric_type< + typename bindings::value_type::type + > const& Numeric) + { + return detail::scale (bindings::size (B), + bindings::begin_value (X), + bindings::begin_value (B), + Numeric.ptr); + } + + + //////////// + // reporting + //////////// + + + // report status + + template + inline + void report_status (control_type const& Control, int status) { + detail::report_status (T(), 0, Control.ptr, status); + } + +#if 0 + template + inline + void report_status (int printing_level, int status) { + control_type Control; + Control[UMFPACK_PRL] = printing_level; + detail::report_status (T(), 0, Control.ptr, status); + } + template + inline + void report_status (int status) { + control_type Control; + detail::report_status (T(), 0, Control.ptr, status); + } +#endif + + + // report control + + template + inline + void report_control (control_type const& Control) { + detail::report_control (T(), 0, Control.ptr); + } + + + // report info + + template + inline + void report_info (control_type const& Control, info_type const& Info) { + detail::report_info (T(), 0, Control.ptr, Info.ptr); + } + +#if 0 + template + inline + void report_info (int printing_level, info_type const& Info) { + control_type Control; + Control[UMFPACK_PRL] = printing_level; + detail::report_info (T(), 0, Control.ptr, Info.ptr); + } + template + inline + void report_info (info_type const& Info) { + control_type Control; + detail::report_info (T(), 0, Control.ptr, Info.ptr); + } +#endif + + + // report matrix (compressed column and coordinate) + + namespace detail { + + template + inline + int report_matrix (tag::compressed_sparse, MatrA const& A, + double const* Control) + { + return detail::report_matrix (bindings::size_row (A), + bindings::size_column (A), + bindings::begin_compressed_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + 1, Control); + } + + template + inline + int report_matrix (tag::coordinate_sparse, MatrA const& A, + double const* Control) + { + return detail::report_triplet (bindings::size_row (A), + bindings::size_column (A), + bindings::end_value (A) - bindings::begin_value (A), + bindings::begin_index_major (A), + bindings::begin_index_minor (A), + bindings::begin_value (A), + Control); + } + + } // detail + + template + inline + int report_matrix (MatrA const& A, + control_type< + typename bindings::value_type::type + > const& Control) + { +#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK + check_umfpack_structure(); +#endif + typedef typename bindings::detail::property_at< + MatrA, tag::data_structure >::type storage_f; + + return detail::report_matrix (storage_f(), A, Control.ptr); + } + + + // report vector + + template + inline + int report_vector (VecX const& X, + control_type< + typename bindings::value_type::type + > const& Control) + { + return detail::report_vector (bindings::size (X), + bindings::begin_value (X), + Control.ptr); + } + + + // report numeric + + template + inline + int report_numeric (numeric_type const& Numeric, + control_type const& Control) + { + return detail::report_numeric (T(), 0, Numeric.ptr, Control.ptr); + } + + + // report symbolic + + template + inline + int report_symbolic (symbolic_type const& Symbolic, + control_type const& Control) + { + return detail::report_symbolic (T(), 0, Symbolic.ptr, Control.ptr); + } + + + // report permutation vector + + template + inline + int report_permutation (VecP const& Perm, control_type const& Control) { +#ifdef CHECK_TEST_COVERAGE + typedef typename T::not_yet_tested i_m_still_here; +#endif + return detail::report_perm (T(), 0, + bindings::begin_value (Perm), + Control.ptr); + } + + +}}}} + +#endif // BOOST_NUMERIC_BINDINGS_UMFPACK_HPP diff --git a/sdk/boost/numeric/bindings/umfpack/umfpack_inc.hpp b/sdk/boost/numeric/bindings/umfpack/umfpack_inc.hpp new file mode 100644 index 0000000..01dd0d8 --- /dev/null +++ b/sdk/boost/numeric/bindings/umfpack/umfpack_inc.hpp @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) Kresimir Fresl 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Author acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + + +/***********************************************************************/ +/* UMFPACK Copyright, License and Availability */ +/***********************************************************************/ +/* + * + * UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A. + * Davis. All Rights Reserved. + * + * UMFPACK License: + * + * Your use or distribution of UMFPACK or any modified version of + * UMFPACK implies that you agree to this License. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY + * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program, provided + * that the Copyright, this License, and the Availability of the original + * version is retained on all copies. User documentation of any code that + * uses UMFPACK or any modified version of UMFPACK code must cite the + * Copyright, this License, the Availability note, and "Used by permission." + * Permission to modify the code and to distribute modified code is granted, + * provided the Copyright, this License, and the Availability note are + * retained, and a notice that the code was modified is included. This + * software was developed with support from the National Science Foundation, + * and is provided to you free of charge. + * + * Availability: + * + * http://www.cise.ufl.edu/research/sparse/umfpack + * + */ + + +/* Used by permission. */ + + +#ifndef BOOST_NUMERIC_BINDINGS_UMFPACK_INC_H +#define BOOST_NUMERIC_BINDINGS_UMFPACK_INC_H + +extern "C" { +#include +} + +#endif diff --git a/sdk/boost/numeric/bindings/umfpack/umfpack_overloads.hpp b/sdk/boost/numeric/bindings/umfpack/umfpack_overloads.hpp new file mode 100644 index 0000000..833e104 --- /dev/null +++ b/sdk/boost/numeric/bindings/umfpack/umfpack_overloads.hpp @@ -0,0 +1,472 @@ +/* + * + * Copyright (c) Kresimir Fresl 2003 + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Author acknowledges the support of the Faculty of Civil Engineering, + * University of Zagreb, Croatia. + * + */ + +/* for UMFPACK Copyright, License and Availability see umfpack_inc.hpp */ + + +#ifndef BOOST_NUMERIC_BINDINGS_UMFPACK_OVERLOADS_HPP +#define BOOST_NUMERIC_BINDINGS_UMFPACK_OVERLOADS_HPP + +#include +#include +#include +#include + +namespace boost { namespace numeric { namespace bindings { + + namespace umfpack { namespace detail { + + //////////////////////////// + // UMFPACK primary routines: + //////////////////////////// + + // symbolic + + inline + int symbolic (int n_row, int n_col, + int const* Ap, int const* Ai, double const* Ax, + void **Symbolic, double const* Control, double* Info) + { + return umfpack_di_symbolic (n_row, n_col, Ap, Ai, Ax, + Symbolic, Control, Info); + } + + inline + int symbolic (int n_row, int n_col, + int const* Ap, int const* Ai, traits::complex_d const* Ax, + void **Symbolic, double const* Control, double* Info) + { + int nnz = Ap[n_col]; + bindings::detail::array Axr (nnz); + if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Axi (nnz); + if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (Ax, Ax+nnz, + Axr.storage(), Axi.storage()); + return umfpack_zi_symbolic (n_row, n_col, Ap, Ai, + Axr.storage(), Axi.storage(), + Symbolic, Control, Info); + } + + + // numeric + + inline + int numeric (int, int, + int const* Ap, int const* Ai, double const* Ax, + void *Symbolic, void **Numeric, + double const* Control, double* Info) + { + return umfpack_di_numeric (Ap, Ai, Ax, Symbolic, Numeric, Control, Info); + } + + inline + int numeric (int, int n_col, + int const* Ap, int const* Ai, traits::complex_d const* Ax, + void *Symbolic, void **Numeric, + double const* Control, double* Info) + { + int nnz = Ap[n_col]; + bindings::detail::array Axr (nnz); + if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Axi (nnz); + if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (Ax, Ax+nnz, + Axr.storage(), Axi.storage()); + return umfpack_zi_numeric (Ap, Ai, Axr.storage(), Axi.storage(), + Symbolic, Numeric, Control, Info); + } + + + // solve + + inline + int solve (int sys, int, + int const* Ap, int const* Ai, double const* Ax, + double* X, double const* B, void *Numeric, + double const* Control, double* Info) + { + return umfpack_di_solve (sys, Ap, Ai, Ax, X, B, Numeric, Control, Info); + } + + inline + int solve (int sys, int n, + int const* Ap, int const* Ai, traits::complex_d const* Ax, + traits::complex_d* X, traits::complex_d const* B, + void *Numeric, double const* Control, double* Info) + { + int nnz = Ap[n]; + bindings::detail::array Axr (nnz); + if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Axi (nnz); + if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (Ax, Ax+nnz, + Axr.storage(), Axi.storage()); + bindings::detail::array Br (n); + if (!Br.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Bi (n); + if (!Bi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (B, B+n, + Br.storage(), Bi.storage()); + bindings::detail::array Xr (n); + if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Xi (n); + if (!Xi.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = umfpack_zi_solve (sys, Ap, Ai, + Axr.storage(), Axi.storage(), + Xr.storage(), Xi.storage(), + Br.storage(), Bi.storage(), + Numeric, Control, Info); + if (status != UMFPACK_OK) return status; + traits::detail::interlace (Xr.storage(), Xr.storage() + n, + Xi.storage(), X); + return status; + } + + + // free_symbolic + + inline + void free_symbolic (double, int, void **Symbolic) { + umfpack_di_free_symbolic (Symbolic); + } + inline + void free_symbolic (traits::complex_d const&, int, void **Symbolic) { + umfpack_zi_free_symbolic (Symbolic); + } + + + // free_numeric + + inline + void free_numeric (double, int, void **Numeric) { + umfpack_di_free_numeric (Numeric); + } + inline + void free_numeric (traits::complex_d const&, int, void **Numeric) { + umfpack_zi_free_numeric (Numeric); + } + + + //////////////////////////////// + // UMFPACK alternative routines: + //////////////////////////////// + + // default control + + inline + void defaults (double, int, double* Control) { + umfpack_di_defaults (Control); + } + inline + void defaults (traits::complex_d const&, int, double* Control) { + umfpack_zi_defaults (Control); + } + + + // symbolic with specified column preordering + + inline + int qsymbolic (int n_row, int n_col, + int const* Ap, int const* Ai, double const* Ax, + int const* Qinit, + void **Symbolic, double const* Control, double* Info) + { + return umfpack_di_qsymbolic (n_row, n_col, Ap, Ai, Ax, Qinit, + Symbolic, Control, Info); + } + + inline + int qsymbolic (int n_row, int n_col, + int const* Ap, int const* Ai, traits::complex_d const* Ax, + int const* Qinit, + void **Symbolic, double const* Control, double* Info) + { + int nnz = Ap[n_col]; + bindings::detail::array Axr (nnz); + if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Axi (nnz); + if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (Ax, Ax+nnz, + Axr.storage(), Axi.storage()); + return umfpack_zi_qsymbolic (n_row, n_col, Ap, Ai, + Axr.storage(), Axi.storage(), + Qinit, Symbolic, Control, Info); + } + + + /////////////////////////////////////// + // UMFPACK matrix manipulation routines + /////////////////////////////////////// + + // triplet (coordinate) to compressed column + + inline + int triplet_to_col (int n_row, int n_col, int nz, + int const* Ti, int const* Tj, double const* Tx, + int* Ap, int* Ai, double* Ax, int* Map) + { + return umfpack_di_triplet_to_col (n_row, n_col, nz, + Ti, Tj, Tx, + Ap, Ai, Ax, Map); + } + + inline + int triplet_to_col (int n_row, int n_col, int nz, + int const* Ti, int const* Tj, + traits::complex_d const* Tx, + int* Ap, int* Ai, traits::complex_d* Ax, + int* Map) + { + assert (Tx == 0 && Ax == 0 || Tx != 0 && Ax != 0); + double *Txr = 0, *Txi = 0; + if (Tx != 0) { + bindings::detail::array ATxr (nz); + if (!ATxr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array ATxi (nz); + if (!ATxi.valid()) return UMFPACK_ERROR_out_of_memory; + Txr = ATxr.storage(); + Txi = ATxi.storage(); + traits::detail::disentangle (Tx, Tx+nz, Txr, Txi); + } + double *Axr = 0, *Axi = 0; + if (Ax != 0) { + bindings::detail::array AAxr (nz); + if (!AAxr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array AAxi (nz); + if (!AAxi.valid()) return UMFPACK_ERROR_out_of_memory; + Axr = AAxr.storage(); + Axi = AAxi.storage(); + } + int status; + status = umfpack_zi_triplet_to_col (n_row, n_col, nz, + Ti, Tj, Txr, Txi, + Ap, Ai, Axr, Axi, Map); + if (Ax != 0) { + if (status != UMFPACK_OK) return status; + traits::detail::interlace (Axr, Axr + nz, Axi, Ax); + } + return status; + } + + + // scale + + inline + int scale (int, double* X, double const* B, void* Numeric) { + return umfpack_di_scale (X, B, Numeric); + } + + inline + int scale (int n, traits::complex_d* X, + traits::complex_d const* B, void* Numeric) + { + bindings::detail::array Br (n); + if (!Br.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Bi (n); + if (!Bi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (B, B+n, + Br.storage(), Bi.storage()); + bindings::detail::array Xr (n); + if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Xi (n); + if (!Xi.valid()) return UMFPACK_ERROR_out_of_memory; + + int status = umfpack_zi_scale (Xr.storage(), Xi.storage(), + Br.storage(), Bi.storage(), + Numeric); + if (status != UMFPACK_OK) return status; + traits::detail::interlace (Xr.storage(), Xr.storage() + n, + Xi.storage(), X); + return status; + } + + + ////////////////////////////// + // UMFPACK reporting routines: + ////////////////////////////// + + // report status + + inline + void report_status (double, int, double const* Control, int status) { + umfpack_di_report_status (Control, status); + } + inline + void report_status (traits::complex_d const&, int, + double const* Control, int status) + { + umfpack_zi_report_status (Control, status); + } + + + // report control + + inline + void report_control (double, int, double const* Control) { + umfpack_di_report_control (Control); + } + inline + void + report_control (traits::complex_d const&, int, double const* Control) { + umfpack_zi_report_control (Control); + } + + + // report info + + inline + void report_info (double, int, double const* Control, double const* Info) { + umfpack_di_report_info (Control, Info); + } + inline + void report_info (traits::complex_d const&, int, + double const* Control, double const* Info) + { + umfpack_zi_report_info (Control, Info); + } + + + // report matrix + + inline + int report_matrix (int n_row, int n_col, + int const* Ap, int const* Ai, double const* Ax, + int col_form, double const* Control) + { + return umfpack_di_report_matrix (n_row, n_col, Ap, Ai, Ax, + col_form, Control); + } + + inline + int report_matrix (int n_row, int n_col, + int const* Ap, int const* Ai, + traits::complex_d const* Ax, + int col_form, double const* Control) + { + int nnz = Ap[n_col]; + bindings::detail::array Axr (nnz); + if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Axi (nnz); + if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (Ax, Ax+nnz, + Axr.storage(), Axi.storage()); + return umfpack_zi_report_matrix (n_row, n_col, Ap, Ai, + Axr.storage(), Axi.storage(), + col_form, Control); + } + + + // report triplet (coordinate) + + inline + int report_triplet (int n_row, int n_col, int nz, + int const* Ti, int const* Tj, double const* Tx, + double const* Control) + { + return umfpack_di_report_triplet (n_row, n_col, nz, Ti, Tj, Tx, Control); + } + + inline + int report_triplet (int n_row, int n_col, int nz, + int const* Ti, int const* Tj, + traits::complex_d const* Tx, + double const* Control) + { + bindings::detail::array Txr (nz); + if (!Txr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Txi (nz); + if (!Txi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (Tx, Tx+nz, + Txr.storage(), Txi.storage()); + return umfpack_zi_report_triplet (n_row, n_col, nz, Ti, Tj, + Txr.storage(), Txi.storage(), + Control); + } + + + // report vector + + inline + int report_vector (int n, double const* X, double const* Control) { + return umfpack_di_report_vector (n, X, Control); + } + + inline + int report_vector (int n, traits::complex_d const* X, + double const* Control) + { +#if 0 + // see UMFPACK v 4.1 User Guide + bindings::detail::array Xr (n); + if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; + bindings::detail::array Xi (n); + if (!Xi.valid()) return UMFPACK_ERROR_out_of_memory; + traits::detail::disentangle (X, X+n, + Xr.storage(), Xi.storage()); + return umfpack_zi_report_vector (n, Xr.storage(), Xi.storage(), Control); +#endif + return umfpack_zi_report_vector (n, + reinterpret_cast (X), + reinterpret_cast (0), + Control); + } + + + // report numeric + + inline + int report_numeric (double, int, void* Numeric, double const* Control) { + return umfpack_di_report_numeric (Numeric, Control); + } + inline + int report_numeric (traits::complex_d const&, int, + void* Numeric, double const* Control) + { + return umfpack_zi_report_numeric (Numeric, Control); + } + + + // report symbolic + + inline + int report_symbolic (double, int, void* Symbolic, double const* Control) { + return umfpack_di_report_symbolic (Symbolic, Control); + } + inline + int report_symbolic (traits::complex_d const&, int, + void* Symbolic, double const* Control) + { + return umfpack_zi_report_symbolic (Symbolic, Control); + } + + + // report permutation vector + + inline + int report_perm (double, int, int np, + int const* Perm, double const* Control) { + return umfpack_di_report_perm (np, Perm, Control); + } + inline + int report_perm (traits::complex_d const&, int, int np, + int const* Perm, double const* Control) { + return umfpack_zi_report_perm (np, Perm, Control); + } + + }} + +}}} + +#endif // BOOST_NUMERIC_BINDINGS_UMFPACK_OVERLOADS_HPP diff --git a/sdk/boost/numeric/bindings/unit_lower.hpp b/sdk/boost/numeric/bindings/unit_lower.hpp new file mode 100644 index 0000000..30a3629 --- /dev/null +++ b/sdk/boost/numeric/bindings/unit_lower.hpp @@ -0,0 +1,45 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UNIT_LOWER_HPP +#define BOOST_NUMERIC_BINDINGS_UNIT_LOWER_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct unit_lower { + typedef detail::basic_wrapper< + T, + mpl::pair< tag::matrix_type, tag::unit_triangular >, + mpl::pair< tag::data_side, tag::lower > + > type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::unit_lower< T >::type const unit_lower( T& underlying ) { + return typename result_of::unit_lower< T >::type( underlying ); +} + +template< typename T > +typename result_of::unit_lower< const T >::type const unit_lower( const T& underlying ) { + return typename result_of::unit_lower< const T >::type( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/unit_upper.hpp b/sdk/boost/numeric/bindings/unit_upper.hpp new file mode 100644 index 0000000..a7cc71a --- /dev/null +++ b/sdk/boost/numeric/bindings/unit_upper.hpp @@ -0,0 +1,45 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UNIT_UPPER_HPP +#define BOOST_NUMERIC_BINDINGS_UNIT_UPPER_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct unit_upper { + typedef detail::basic_wrapper< + T, + mpl::pair< tag::matrix_type, tag::unit_triangular >, + mpl::pair< tag::data_side, tag::upper > + > type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::unit_upper< T >::type const unit_upper( T& underlying ) { + return typename result_of::unit_upper< T >::type( underlying ); +} + +template< typename T > +typename result_of::unit_upper< const T >::type const unit_upper( const T& underlying ) { + return typename result_of::unit_upper< const T >::type( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/uplo_tag.hpp b/sdk/boost/numeric/bindings/uplo_tag.hpp new file mode 100644 index 0000000..e726b07 --- /dev/null +++ b/sdk/boost/numeric/bindings/uplo_tag.hpp @@ -0,0 +1,77 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UPLO_TAG_HPP +#define BOOST_NUMERIC_BINDINGS_UPLO_TAG_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename DataSide, typename TransTag > +struct uplo_tag_impl { + // If your program complains about this part, this probably + // means that you are trying to use row_major matrices where you + // should use column_major matrices. +}; + +template<> +struct uplo_tag_impl< tag::upper, tag::no_transpose > { + typedef tag::upper type; +}; + +template< typename TransTag > +struct uplo_tag_impl< tag::upper, TransTag > { + typedef tag::lower type; +}; + +template<> +struct uplo_tag_impl< tag::lower, tag::no_transpose > { + typedef tag::lower type; +}; + +template< typename TransTag > +struct uplo_tag_impl< tag::lower, TransTag > { + typedef tag::upper type; +}; + +} // namespace detail + +namespace result_of { + +template< typename T, typename Trans = tag::no_transpose > +struct uplo_tag { + typedef typename detail::uplo_tag_impl< + typename detail::property_at< T, tag::data_side >::type, + Trans + >::type type; +}; + +} // namespace result_of + +// +// uplo_tag will output tags that are compatible with BLAS and LAPACK, either one +// of tag::transpose, tag::no_transpose, or tag::conjugate. +// It needs an library-orientation (Trans) before it can make a decision about whether +// a tranpose is in order. Consult the various cases above to see what kind of +// tag is being generated in what kind of situation. +// +template< typename T, typename Trans > +typename result_of::uplo_tag< T, Trans >::type uplo_tag( const T& t, Trans ) { + return result_of::uplo_tag< T, Trans >::type(); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/upper.hpp b/sdk/boost/numeric/bindings/upper.hpp new file mode 100644 index 0000000..196b0e7 --- /dev/null +++ b/sdk/boost/numeric/bindings/upper.hpp @@ -0,0 +1,45 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_UPPER_HPP +#define BOOST_NUMERIC_BINDINGS_UPPER_HPP + +#include +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace result_of { + +template< typename T > +struct upper { + typedef detail::basic_wrapper< + T, + mpl::pair< tag::matrix_type, tag::triangular >, + mpl::pair< tag::data_side, tag::upper > + > type; +}; + +} // namespace result_of + +template< typename T > +typename result_of::upper< T >::type const upper( T& underlying ) { + return typename result_of::upper< T >::type( underlying ); +} + +template< typename T > +typename result_of::upper< const T >::type const upper( const T& underlying ) { + return typename result_of::upper< const T >::type( underlying ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/value_type.hpp b/sdk/boost/numeric/bindings/value_type.hpp new file mode 100644 index 0000000..545a14b --- /dev/null +++ b/sdk/boost/numeric/bindings/value_type.hpp @@ -0,0 +1,27 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_VALUE_TYPE_HPP +#define BOOST_NUMERIC_BINDINGS_VALUE_TYPE_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { + +template< typename T > +struct value_type { + typedef typename detail::property_at< T, tag::value_type >::type type; +}; + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/vector_view.hpp b/sdk/boost/numeric/bindings/vector_view.hpp new file mode 100644 index 0000000..f48ed09 --- /dev/null +++ b/sdk/boost/numeric/bindings/vector_view.hpp @@ -0,0 +1,83 @@ +// +// Copyright (c) 2009 Rutger ter Borg +// Copyright (c) 2010 Thomas Klimpel +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_VECTOR_VIEW_HPP +#define BOOST_NUMERIC_BINDINGS_VECTOR_VIEW_HPP + +#include + +namespace boost { +namespace numeric { +namespace bindings { +namespace detail { + +template< typename T > +struct vector_view_wrapper: + adaptable_type< vector_view_wrapper > { + typedef T value_type; + + vector_view_wrapper( T* t, std::size_t size ): + m_t( t ), + m_size( size ) {} + T* m_t; + std::size_t m_size; +}; + +template< typename T, typename Id, typename Enable > +struct adaptor< vector_view_wrapper, Id, Enable > { + + typedef typename Id::value_type value_type; + typedef mpl::map< + mpl::pair< tag::value_type, value_type >, + mpl::pair< tag::entity, tag::vector >, + mpl::pair< tag::size_type<1>, std::ptrdiff_t >, + mpl::pair< tag::data_structure, tag::linear_array >, + mpl::pair< tag::stride_type<1>, tag::contiguous > + > property_map; + + static std::ptrdiff_t size1( const Id& id ) { + return id.m_size; + } + + static value_type* begin_value( Id& id ) { + return id.m_t; + } + + static value_type* end_value( Id& id ) { + return id.m_t + id.m_size; + } + +}; + +} // namespace detail + +namespace result_of { + +template< typename T > +struct vector_view { + typedef detail::vector_view_wrapper type; +}; + +} // namespace result_of + +template< typename T > +detail::vector_view_wrapper const vector_view( T* t, std::size_t size ) { + return detail::vector_view_wrapper( t, size ); +} + +template< typename T > +detail::vector_view_wrapper const vector_view( const T* t, std::size_t size ) { + return detail::vector_view_wrapper( t, size ); +} + +} // namespace bindings +} // namespace numeric +} // namespace boost + +#endif diff --git a/sdk/boost/numeric/bindings/views.hpp b/sdk/boost/numeric/bindings/views.hpp new file mode 100644 index 0000000..20e3973 --- /dev/null +++ b/sdk/boost/numeric/bindings/views.hpp @@ -0,0 +1,26 @@ +// +// Copyright (c) 2010 Thomas Klimpel +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BOOST_NUMERIC_BINDINGS_WRAPPER_HPP +#define BOOST_NUMERIC_BINDINGS_WRAPPER_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif + diff --git a/sdk/buddy-2.4/AUTHORS b/sdk/buddy-2.4/AUTHORS new file mode 100644 index 0000000..8af5ba6 --- /dev/null +++ b/sdk/buddy-2.4/AUTHORS @@ -0,0 +1,11 @@ +Jorn Lind-Nielsen - Original Developer +Alan Mishchenko +Gerd Behrmann +Henrik Hulgaard +Henrik Reif Andersen +Jacob Lichtenberg +Ken Larsen +Nicola Soranzo +Nikolaj Bjorner +Alexandre Duret-Lutz +Haim Cohen diff --git a/sdk/buddy-2.4/CHANGES b/sdk/buddy-2.4/CHANGES new file mode 100644 index 0000000..e69de29 diff --git a/sdk/buddy-2.4/CMakeLists.txt b/sdk/buddy-2.4/CMakeLists.txt new file mode 100644 index 0000000..b2eeae0 --- /dev/null +++ b/sdk/buddy-2.4/CMakeLists.txt @@ -0,0 +1,26 @@ +# This file is part of EPOCH. +# File: CMakeLists.txt +# Author: Xavier Pucel +# Contact: xavier.pucel@onera.fr +# +# EPOCH 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. +# +# EPOCH 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 EPOCH. If not, see . + +INCLUDE(ExternalProject) + +ExternalProject_Add(buddy-2.4 + PREFIX ${CMAKE_BINARY_DIR}/sdk/buddy-2.4 + SOURCE_DIR ${CMAKE_SOURCE_DIR}/sdk/buddy-2.4/src + CONFIGURE_COMMAND ${CMAKE_SOURCE_DIR}/sdk/buddy-2.4/configure --prefix=${CMAKE_BINARY_DIR}/sdk/buddy-2.4 --silent + BUILD_COMMAND make install +) diff --git a/sdk/buddy-2.4/ChangeLog b/sdk/buddy-2.4/ChangeLog new file mode 100644 index 0000000..4291462 --- /dev/null +++ b/sdk/buddy-2.4/ChangeLog @@ -0,0 +1,218 @@ +2004-07-22 haimcohen + + * NEWS 1.2, ChangeLog 1.4: *** empty log message *** + + * examples/solitare/Makefile.am 1.3, examples/solitare/expected 1.2, examples/solitare/runtest 1.2: + Solitare will not be included in the regression since it takes too much time to run + +2004-07-21 haimcohen + + * ChangeLog 1.3, examples/bddcalc/expected 1.2: + *** empty log message *** + + * src/depend.inf 1.2: + we do not need this file anymore since autotools are being used + + * examples/solitare/Makefile.am 1.2: readme was added to distribution + + * doc/Makefile.am 1.2: buddy.ps and tech.txt were added to distribution + +2004-07-14 haimcohen + + * ChangeLog 1.2, tools/.cvsignore 1.1: *** empty log message *** + + * examples/solitare/expected 1.1: + This file is empty in purpose. The solitare test takes too much memory + than I can afford. Until I generate this file somehow, the solitare + test should not be run. + + * examples/milner/expected 1.1: *** empty log message *** + + * examples/queen/expected 1.1, examples/bddcalc/expected 1.1, examples/bddtest/expected 1.1, examples/cmilner/expected 1.1, examples/fdd/expected 1.1, examples/money/expected 1.1, examples/adder/expected 1.1: + These files are part of the new regression suite. Each file contains + the expected result of a test. + + * examples/cmilner/Makefile.am 1.1, examples/fdd/Makefile.am 1.1, examples/milner/Makefile.am 1.1, examples/money/Makefile.am 1.1, examples/queen/Makefile.am 1.1, examples/solitare/Makefile.am 1.1: + Added to support autotools + + * examples/fdd/makefile 1.2, examples/milner/makefile 1.2, examples/money/makefile 1.2, examples/queen/makefile 1.2, examples/solitare/makefile 1.2, examples/adder/makefile 1.2, examples/bddtest/makefile 1.2, examples/cmilner/makefile 1.2: + We don't need the makefles anymore since we are using autotools now, + thanks to Alexandre's contribution. + + * examples/bddcalc/lexer.lxx 1.1, examples/bddcalc/parser.yxx 1.1, examples/bddcalc/parser_.h 1.1, examples/bddcalc/lexer.l 1.2, examples/bddcalc/makefile 1.3, examples/bddcalc/parser.h 1.2, examples/bddcalc/parser.y 1.3: + *** empty log message *** + + * examples/runregression 1.1: + +2004-07-13 haimcohen + + * examples/fdd/runtest 1.1, examples/money/runtest 1.1, examples/queen/runtest 1.1, examples/solitare/runtest 1.1: + A simple script to run a regression test and generate output + + * examples/milner/runtest 1.1: *** empty log message *** + + * examples/adder/runtest 1.1, examples/bddcalc/runtest 1.1, examples/bddtest/runtest 1.1, examples/cmilner/runtest 1.1: + A simple script to run a regression test and generate output + + * examples/Makefile.am 1.1, examples/Makefile.def 1.1, examples/adder/Makefile.am 1.1, examples/bddcalc/Makefile.am 1.1, examples/bddtest/Makefile.am 1.1: + Support for autotools + + * examples/solitare/.cvsignore 1.1, examples/.cvsignore 1.1, examples/adder/.cvsignore 1.1, examples/bddcalc/.cvsignore 1.1, examples/bddtest/.cvsignore 1.1, examples/cmilner/.cvsignore 1.1, examples/fdd/.cvsignore 1.1, examples/milner/.cvsignore 1.1, examples/money/.cvsignore 1.1, examples/queen/.cvsignore 1.1: + *** empty log message *** + + * src/kernel.c 1.2: Changed the returned BuDDy version format. + + * src/kernel.h 1.2: + The default value DEFAULT_CLOCK is now defined in the file instead of in the makefile. It can be changed using parameter to configure. By Alexandre. + + * src/.cvsignore 1.1, src/Makefile.am 1.1, src/makefile 1.2: + for autoconf support + +2004-07-12 haimcohen + + * doc/makefile 1.2, doc/.cvsignore 1.1: *** empty log message *** + + * doc/tech.txt 1.1: From the original BuDDy distribution + + * doc/Makefile.am 1.1: Added to enable autoconf + + * m4/debug.m4 1.1: *** empty log message *** + + * README 1.3: Modified to exaplin how to use configure. By Alexandre. + + * config 1.2, makefile 1.2, .cvsignore 1.1: *** empty log message *** + + * CHANGES 1.2: + Empty file - autoconf require CHANGES file. Changes will appear in the NEWS file, and changes for developers will be in the ChangeLog. + + * AUTHORS 1.1, ChangeLog 1.1, Makefile.am 1.1, NEWS 1.1, README.CVS 1.1, configure.ac 1.1: + Added for configure support + +2004-07-02 haimcohen + + * examples/bddcalc/makefile 1.2: + tokens.h was added to the 'clean' target as it is generated by yacc + + * examples/bddcalc/parser.y 1.2: + Tokens were separated by spaces instead of commas to comply with POSIX standard. + Patch was supplied by Alexandre Duret-Lutz + +2004-07-01 haimcohen + + * examples/bddcalc/parser.hxx 1.2, examples/bddcalc/tokens.h 1.2: + File removed since it did not have to be in CVS from the beginning - this file is generated by yacc. + +2004-06-25 haimcohen + + * README 1.2: Change Haim Cohens Email to the one in Source Forge + + * src/depend.inf 1.1.1.1, src/makefile 1.1.1.1, src/tree.c 1.1.1.1: + Initial import + + * src/depend.inf 1.1, src/makefile 1.1, src/tree.c 1.1: New file. + + * src/reorder.c 1.1.1.1: Initial import + + * src/reorder.c 1.1: New file. + + * src/prime.h 1.1.1.1: Initial import + + * src/prime.h 1.1: New file. + + * src/prime.c 1.1.1.1: Initial import + + * src/prime.c 1.1: New file. + + * src/kernel.c 1.1.1.1, src/kernel.h 1.1.1.1, src/pairs.c 1.1.1.1: + Initial import + + * src/kernel.c 1.1, src/kernel.h 1.1, src/pairs.c 1.1: New file. + + * src/imatrix.c 1.1.1.1, src/imatrix.h 1.1.1.1: Initial import + + * src/imatrix.c 1.1, src/imatrix.h 1.1: New file. + + * src/fdd.c 1.1.1.1, src/fdd.h 1.1.1.1: Initial import + + * src/fdd.c 1.1, src/fdd.h 1.1: New file. + + * src/cppext.cxx 1.1.1.1: Initial import + + * src/cppext.cxx 1.1: New file. + + * src/bvec.c 1.1.1.1, src/bvec.h 1.1.1.1, src/cache.c 1.1.1.1, src/cache.h 1.1.1.1: + Initial import + + * src/bvec.c 1.1, src/bvec.h 1.1, src/cache.c 1.1, src/cache.h 1.1: + New file. + + * src/bddtest.cxx 1.1.1.1, src/bddtree.h 1.1.1.1: Initial import + + * src/bddtest.cxx 1.1, src/bddtree.h 1.1: New file. + + * src/bddop.c 1.1.1.1: Initial import + + * src/bddop.c 1.1: New file. + + * src/bddio.c 1.1.1.1: Initial import + + * src/bddio.c 1.1: New file. + + * src/bdd.h 1.1.1.1: Initial import + + * src/bdd.h 1.1: New file. + + * examples/bddcalc/examples/c3540.cal 1.1.1.1, examples/bddcalc/examples/c432.cal 1.1.1.1: + Initial import + + * examples/bddcalc/examples/c3540.cal 1.1, examples/bddcalc/examples/c432.cal 1.1: + New file. + + * examples/bddcalc/examples/c1355.cal 1.1.1.1, examples/bddcalc/examples/c499.cal 1.1.1.1: + Initial import + + * examples/bddcalc/examples/c1355.cal 1.1, examples/bddcalc/examples/c499.cal 1.1: + New file. + + * examples/bddcalc/examples/c1908.cal 1.1.1.1, examples/bddcalc/examples/c2670.cal 1.1.1.1, examples/bddcalc/examples/readme 1.1.1.1: + Initial import + + * examples/bddcalc/examples/c1908.cal 1.1, examples/bddcalc/examples/c2670.cal 1.1, examples/bddcalc/examples/readme 1.1: + New file. + + * examples/bddcalc/parser.hxx 1.1.1.1, examples/bddcalc/slist.h 1.1.1.1, examples/bddcalc/tokens.h 1.1.1.1: + Initial import + + * examples/bddcalc/parser.hxx 1.1, examples/bddcalc/slist.h 1.1, examples/bddcalc/tokens.h 1.1: + New file. + + * examples/bddcalc/parser.y 1.1.1.1, examples/bddcalc/readme 1.1.1.1: + Initial import + + * examples/bddcalc/parser.y 1.1, examples/bddcalc/readme 1.1: New file. + + * examples/bddcalc/parser.h 1.1.1.1: Initial import + + * examples/bddcalc/parser.h 1.1: New file. + + * examples/adder/adder.cxx 1.1.1.1, examples/adder/makefile 1.1.1.1, examples/bddcalc/example.cal 1.1.1.1, examples/bddcalc/hashtbl.cxx 1.1.1.1, examples/bddcalc/hashtbl.h 1.1.1.1, examples/bddcalc/lexer.l 1.1.1.1, examples/bddcalc/makefile 1.1.1.1, examples/bddtest/bddtest.cxx 1.1.1.1, examples/bddtest/makefile 1.1.1.1, examples/cmilner/cmilner.c 1.1.1.1, examples/fdd/fdd.cxx 1.1.1.1, examples/fdd/makefile 1.1.1.1, examples/money/makefile 1.1.1.1, examples/money/money.cxx 1.1.1.1, examples/queen/makefile 1.1.1.1, examples/queen/queen.cxx 1.1.1.1, examples/solitare/makefile 1.1.1.1, examples/solitare/readme 1.1.1.1, examples/solitare/solitare.cxx 1.1.1.1: + Initial import + + * examples/adder/adder.cxx 1.1, examples/adder/makefile 1.1, examples/bddcalc/example.cal 1.1, examples/bddcalc/hashtbl.cxx 1.1, examples/bddcalc/hashtbl.h 1.1, examples/bddcalc/lexer.l 1.1, examples/bddcalc/makefile 1.1, examples/bddtest/bddtest.cxx 1.1, examples/bddtest/makefile 1.1, examples/cmilner/cmilner.c 1.1, examples/fdd/fdd.cxx 1.1, examples/fdd/makefile 1.1, examples/money/makefile 1.1, examples/money/money.cxx 1.1, examples/queen/makefile 1.1, examples/queen/queen.cxx 1.1, examples/solitare/makefile 1.1, examples/solitare/readme 1.1, examples/solitare/solitare.cxx 1.1: + New file. + + * doc/bddnotes.ps 1.1.1.1, doc/makefile 1.1.1.1, examples/cmilner/makefile 1.1.1.1, examples/cmilner/readme 1.1.1.1, examples/milner/makefile 1.1.1.1, examples/milner/milner.cxx 1.1.1.1, examples/milner/readme 1.1.1.1: + Initial import + + * doc/bddnotes.ps 1.1, doc/makefile 1.1, examples/cmilner/makefile 1.1, examples/cmilner/readme 1.1, examples/milner/makefile 1.1, examples/milner/milner.cxx 1.1, examples/milner/readme 1.1: + New file. + + * doc/buddy.ps 1.1.1.1: Initial import + + * doc/buddy.ps 1.1: New file. + + * CHANGES 1.1.1.1, README 1.1.1.1, config 1.1.1.1, makefile 1.1.1.1: + Initial import + + * CHANGES 1.1, README 1.1, config 1.1, makefile 1.1: New file. + diff --git a/sdk/buddy-2.4/Makefile.am b/sdk/buddy-2.4/Makefile.am new file mode 100644 index 0000000..86c0709 --- /dev/null +++ b/sdk/buddy-2.4/Makefile.am @@ -0,0 +1,5 @@ +ACLOCAL_AMFLAGS = -I m4 + +SUBDIRS = src + +EXTRA_DIST = CHANGES m4/debug.m4 diff --git a/sdk/buddy-2.4/Makefile.in b/sdk/buddy-2.4/Makefile.in new file mode 100644 index 0000000..d88e2c9 --- /dev/null +++ b/sdk/buddy-2.4/Makefile.in @@ -0,0 +1,599 @@ +# Makefile.in generated by automake 1.8.5 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +top_builddir = . +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +INSTALL = @INSTALL@ +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +host_triplet = @host@ +DIST_COMMON = README $(am__configure_deps) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in $(srcdir)/config.h.in \ + $(top_srcdir)/configure AUTHORS ChangeLog NEWS \ + tools/config.guess tools/config.sub tools/depcomp \ + tools/install-sh tools/ltmain.sh tools/missing +subdir = . +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/debug.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ + configure.lineno configure.status.lineno +mkinstalldirs = $(mkdir_p) +CONFIG_HEADER = config.h +CONFIG_CLEAN_FILES = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-exec-recursive install-info-recursive \ + install-recursive installcheck-recursive installdirs-recursive \ + pdf-recursive ps-recursive uninstall-info-recursive \ + uninstall-recursive +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = $(SUBDIRS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +distdir = $(PACKAGE)-$(VERSION) +top_distdir = $(distdir) +am__remove_distdir = \ + { test ! -d $(distdir) \ + || { find $(distdir) -type d ! -perm -200 -exec chmod u+w {} ';' \ + && rm -fr $(distdir); }; } +DIST_ARCHIVES = $(distdir).tar.gz +GZIP_ENV = --best +distuninstallcheck_listfiles = find . -type f -print +distcleancheck_listfiles = find . -type f -print +ACLOCAL = @ACLOCAL@ +AMDEP_FALSE = @AMDEP_FALSE@ +AMDEP_TRUE = @AMDEP_TRUE@ +AMTAR = @AMTAR@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +ECHO = @ECHO@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +F77 = @F77@ +FFLAGS = @FFLAGS@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LDFLAGS = @LDFLAGS@ +LEX = @LEX@ +LEXLIB = @LEXLIB@ +LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +OBJEXT = @OBJEXT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +RANLIB = @RANLIB@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +YACC = @YACC@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_F77 = @ac_ct_F77@ +ac_ct_RANLIB = @ac_ct_RANLIB@ +ac_ct_STRIP = @ac_ct_STRIP@ +am__fastdepCC_FALSE = @am__fastdepCC_FALSE@ +am__fastdepCC_TRUE = @am__fastdepCC_TRUE@ +am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@ +am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +datadir = @datadir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +ACLOCAL_AMFLAGS = -I m4 +SUBDIRS = src +EXTRA_DIST = CHANGES m4/debug.m4 +all: config.h + $(MAKE) $(AM_MAKEFLAGS) all-recursive + +.SUFFIXES: +am--refresh: + @: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + echo ' cd $(srcdir) && $(AUTOMAKE) --foreign '; \ + cd $(srcdir) && $(AUTOMAKE) --foreign \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --foreign Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + echo ' $(SHELL) ./config.status'; \ + $(SHELL) ./config.status;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + $(SHELL) ./config.status --recheck + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(srcdir) && $(AUTOCONF) +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) + +config.h: stamp-h1 + @if test ! -f $@; then \ + rm -f stamp-h1; \ + $(MAKE) stamp-h1; \ + else :; fi + +stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status + @rm -f stamp-h1 + cd $(top_builddir) && $(SHELL) ./config.status config.h +$(srcdir)/config.h.in: $(am__configure_deps) + cd $(top_srcdir) && $(AUTOHEADER) + rm -f stamp-h1 + touch $@ + +distclean-hdr: + -rm -f config.h stamp-h1 + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool +uninstall-info-am: + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @set fnord $$MAKEFLAGS; amf=$$2; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +mostlyclean-recursive clean-recursive distclean-recursive \ +maintainer-clean-recursive: + @set fnord $$MAKEFLAGS; amf=$$2; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + $(am__remove_distdir) + mkdir $(distdir) + $(mkdir_p) $(distdir)/m4 $(distdir)/tools + @srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \ + list='$(DISTFILES)'; for file in $$list; do \ + case $$file in \ + $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \ + $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \ + esac; \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test "$$dir" != "$$file" && test "$$dir" != "."; then \ + dir="/$$dir"; \ + $(mkdir_p) "$(distdir)$$dir"; \ + else \ + dir=''; \ + fi; \ + if test -d $$d/$$file; then \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -d "$(distdir)/$$subdir" \ + || mkdir "$(distdir)/$$subdir" \ + || exit 1; \ + (cd $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="../$(top_distdir)" \ + distdir="../$(distdir)/$$subdir" \ + distdir) \ + || exit 1; \ + fi; \ + done + -find $(distdir) -type d ! -perm -777 -exec chmod a+rwx {} \; -o \ + ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -444 -exec $(SHELL) $(install_sh) -c -m a+r {} {} \; \ + || chmod -R a+r $(distdir) +dist-gzip: distdir + $(AMTAR) chof - $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + $(am__remove_distdir) + +dist-bzip2: distdir + $(AMTAR) chof - $(distdir) | bzip2 -9 -c >$(distdir).tar.bz2 + $(am__remove_distdir) + +dist-tarZ: distdir + $(AMTAR) chof - $(distdir) | compress -c >$(distdir).tar.Z + $(am__remove_distdir) + +dist-shar: distdir + shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz + $(am__remove_distdir) + +dist-zip: distdir + -rm -f $(distdir).zip + zip -rq $(distdir).zip $(distdir) + $(am__remove_distdir) + +dist dist-all: distdir + $(AMTAR) chof - $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + $(am__remove_distdir) + +# This target untars the dist file and tries a VPATH configuration. Then +# it guarantees that the distribution is self-contained by making another +# tarfile. +distcheck: dist + case '$(DIST_ARCHIVES)' in \ + *.tar.gz*) \ + GZIP=$(GZIP_ENV) gunzip -c $(distdir).tar.gz | $(AMTAR) xf - ;;\ + *.tar.bz2*) \ + bunzip2 -c $(distdir).tar.bz2 | $(AMTAR) xf - ;;\ + *.tar.Z*) \ + uncompress -c $(distdir).tar.Z | $(AMTAR) xf - ;;\ + *.shar.gz*) \ + GZIP=$(GZIP_ENV) gunzip -c $(distdir).shar.gz | unshar ;;\ + *.zip*) \ + unzip $(distdir).zip ;;\ + esac + chmod -R a-w $(distdir); chmod a+w $(distdir) + mkdir $(distdir)/_build + mkdir $(distdir)/_inst + chmod a-w $(distdir) + dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ + && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ + && cd $(distdir)/_build \ + && ../configure --srcdir=.. --prefix="$$dc_install_base" \ + $(DISTCHECK_CONFIGURE_FLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) dvi \ + && $(MAKE) $(AM_MAKEFLAGS) check \ + && $(MAKE) $(AM_MAKEFLAGS) install \ + && $(MAKE) $(AM_MAKEFLAGS) installcheck \ + && $(MAKE) $(AM_MAKEFLAGS) uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ + distuninstallcheck \ + && chmod -R a-w "$$dc_install_base" \ + && ({ \ + (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ + distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ + } || { rm -rf "$$dc_destdir"; exit 1; }) \ + && rm -rf "$$dc_destdir" \ + && $(MAKE) $(AM_MAKEFLAGS) dist \ + && rm -rf $(DIST_ARCHIVES) \ + && $(MAKE) $(AM_MAKEFLAGS) distcleancheck + $(am__remove_distdir) + @(echo "$(distdir) archives ready for distribution: "; \ + list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ + sed -e '1{h;s/./=/g;p;x;}' -e '$${p;x;}' +distuninstallcheck: + @cd $(distuninstallcheck_dir) \ + && test `$(distuninstallcheck_listfiles) | wc -l` -le 1 \ + || { echo "ERROR: files left after uninstall:" ; \ + if test -n "$(DESTDIR)"; then \ + echo " (check DESTDIR support)"; \ + fi ; \ + $(distuninstallcheck_listfiles) ; \ + exit 1; } >&2 +distcleancheck: distclean + @if test '$(srcdir)' = . ; then \ + echo "ERROR: distcleancheck can only run from a VPATH build" ; \ + exit 1 ; \ + fi + @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left in build directory after distclean:" ; \ + $(distcleancheck_listfiles) ; \ + exit 1; } >&2 +check-am: all-am +check: check-recursive +all-am: Makefile config.h +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-hdr \ + distclean-libtool distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +info: info-recursive + +info-am: + +install-data-am: + +install-exec-am: + +install-info: install-info-recursive + +install-man: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -rf $(top_srcdir)/autom4te.cache + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: uninstall-info-am + +uninstall-info: uninstall-info-recursive + +.PHONY: $(RECURSIVE_TARGETS) CTAGS GTAGS all all-am am--refresh check \ + check-am clean clean-generic clean-libtool clean-recursive \ + ctags ctags-recursive dist dist-all dist-bzip2 dist-gzip \ + dist-shar dist-tarZ dist-zip distcheck distclean \ + distclean-generic distclean-hdr distclean-libtool \ + distclean-recursive distclean-tags distcleancheck distdir \ + distuninstallcheck dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-exec \ + install-exec-am install-info install-info-am install-man \ + install-strip installcheck installcheck-am installdirs \ + installdirs-am maintainer-clean maintainer-clean-generic \ + maintainer-clean-recursive mostlyclean mostlyclean-generic \ + mostlyclean-libtool mostlyclean-recursive pdf pdf-am ps ps-am \ + tags tags-recursive uninstall uninstall-am uninstall-info-am + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/sdk/buddy-2.4/NEWS b/sdk/buddy-2.4/NEWS new file mode 100644 index 0000000..d1db04c --- /dev/null +++ b/sdk/buddy-2.4/NEWS @@ -0,0 +1,200 @@ +---------------------------------------------------------------------------- + User visible changes to BuDDy +---------------------------------------------------------------------------- + ++ means added code +x means bugfix or changed code +- means removed code + +VER 2.4 (July 2004) +------------------- + + Using configure script for the build process. + + Adding runregression script which runs examples and compare to + expected results. + +VER 2.3 (June 2004) +------------------- + + Nothing :-( This is just the first version in SourceForge, + so it deserved its own number. + +VER 2.2 (november 2002) +----------------------- + + Added bvec_ite() for calculating an if-then-else operation on + a boolean vector. + x Fixed some garbage collection problems introduced in version 2.1. + + +VER 2.1 (march 2002) +-------------------- + + Added bdd_allsat() for calculating all possible variable assignments + to a bdd. + x Fixed some wrong garbage collection #defines in kernel.h. If you + haven't experinced any problems using BuDDy, then this should not + be an issue. No bug reports reported for this one - found by code + inspection thanx to Nicola Soranzo. + x Fixed some copy paste errors in the prime number calculation. + This should not be an issue. No bug reports reported for this one + - found by code inspection thanx to Nicola Soranzo. + + +VER 2.0 (march 2001) +-------------------- + x Change the copyright notice to a more acceptable form. + x Speedup changes in bdd_support() + x Rewrote all the prime number calculations in order to get the + copyright right. + + +VER 1.9 (august 2000) +--------------------- + + Added bdd_pathcount + + Added bdd_anodecount + + Added bdd_buildcube, bdd_ibuildcube + x Bugfix in bdd_satcountset and bdd_satcountlnset. This corrects a bug + introduced in version 1.8. + x bug fixes in bdd_constraint and bdd_simplify. Both did calculate a + correct cofactor, but not necessarily a minimal one. Changed the name + of bdd_constraint to bdd_constrain at the same time. + x bug fix in memory allocation for bdd_addvarblock + x Changed functions in bddop.c in order to avoid some compiler warnings. + x Makefile also installs "fdd.h" and "bvec.h". + x Small #include fix in N-Queen example. + x Minor changes in the documentation. + + +VER 1.8 (may 2000) +------------------ + + Bugfix in the kernel: canonicity was not unfortunately not guaranteed + on certain compilers (at least the microsoft visual C compiler) due to a + signed/unsigned bug in kernel.c (and actually not microsofts fault). + + Speedups in the reordering code. + + Added the use of an interaction matrix for variable swapping. + + Added bdd_satoneset + + Added bdd_getallocnum + + Added bdd_setvarorder + + Added bdd_unique, bdd_appuni. + + Added bvec_shlfixed, bvec_shrfixed and changed the prototype for + bvec_shl and bvec_shr. + + Added bvec_mulfixed, bdd_divfixed, bdd_div and changed the + prototype for bvec_mul. + + Added bdd_printstat + + Added new examples: solitare and money + + Forces cache tables to prime-number size. + + Added bdd_clear_error() if anybody needs that. + + Added reorder method WIN3 and WIN3ITE + x Small change in queen.cxx - with a huge impact on runtime! + x Bugfix in reordering. In some cases reordering would go on forever; + first reroder, then retry, then reorder again without resize etc. always + reordering in the same operation. Now at most one reordering is allowed + for each bdd operation. + x Bugfix in C++ printing in Dot format. Wrote zero for one and vice versa. + x Bugfix in the garbage collector. If bdd_setmaxincrease was used, then + BuDDy would call bdd_error prematurely. Not a major bug, but annoying. + x Bugfix in bdd_load. + x Speedup in bdd_satcountset and bdd_satcountlnset + x Updates to the docs. + x Updates to the makefiles + + +VER 1.7 (september 1999) +------------------------ + + Added support for boolean vector operations used in integer arithmetics + + Split "bdd.h" into "bdd.h", "fdd.h" and "bvec.h" + + Added bdd_cachestats + + Added bdd_and, bdd_or, bdd_xor, bdd_impl, bdd_biimpl + (wrappers for bdd_apply). + + Added a BDD calculator for combinatorial circuits as an example. + + Added an example showing the use of the FDD interface. + + Added bdd_autoreorder_times, bdd_getreorder_method, bdd_getreorder_times, + bdd_reorder_probe, bdd_enable_reorder, bdd_disable_reorder, + bdd_var2level, bdd_level2var, bdd_reorder_gain, bdd_swapvar + + Added bdd_file_hook, bdd_strm_hook, fdd_file_hook, fdd_strm_hook + + Added support for dynamic resizing of the operator caches with + the function bdd_setcacheratio. + + Added more documentation. + x Bugfix in reordering code. This would appear when recursive variable + blocks were defined (blocks with sub-blocks). + x Speedup changes in the variable reordering code + x The automatic reordering threshhold function has been changed + x Automatic reordering is now interrupting and restarts bdd operations + x Prototype for bdd_reorder_hook changed. + x Printing of reorder information (verbose level > 0) is changed. + x The threshold for stopping of the iterative reordering methods has + been changed. The reordering now continues until no progress is done + at all (before it would stop when less than 5% where gained). + x Added a few sanity checks to many of the functions. + x Bugfix (parameter checking) in fdd_ithvar. + - bdd_varlevel removed (use bdd_var2level and bdd_level2var). + + +VER 1.6 (november 1998) +----------------------- + + Added bdd_resetpair + + Added bdd_satcountset, bdd_satcountlnset + + Added macro bdd_relprod + + Added fdd_overlapdomain + + Added fdd_domain + x Fixed a bug in bdd_setvarnum and bdd_extvarnum. + x Fixed a bug in bdd_newpair() which would give problems with reordering. + x Speedup changes in bdd_exist, bdd_forall, bdd_appex, bdd_appall + x Speedup changes in bdd_restrict + x Changed bdd_gbc_hook to include both pre and post garbage collection. + + +VER 1.5 (september 1998) +------------------------ + + Added bdd_cofactor + + Added and fixed some error checks in fdd.c + x Fixed a bug in bdd_setvarnum(). + + +VER 1.4 (july 1998) +------------------- + The package just got a name: BuDDy + + Added functions bdd_compose, bdd_veccompose, bdd_ite. + + Added functions bdd_setbddpair, bdd_setbddpairs. + + Added functions bdd_var, bdd_low, bdd_high. + + Added technical documentation in docs/tech.txt + x Overloaded C++ functions are not used any more. This mainly changes + the name of the printing functions in C++. + x Changed datatype names (You'll hate me for this one): + BddPair -> bddPair + BddStat -> bddStat + BddGbcStat -> bddGbcStat + x Added slightly more documentation. + x Some internal changes to the code - should not be visible to users. + + +VER 1.3 (june 1998) +------------------- + x Fixed a few serious bugs in the reordering code + + +VER 1.2 (june 1998) +------------------- + + Added support for dynamic variable reordering + + Added reordering handler (bdd_reorder_hook) + + More added to the docs + x Changed the event handlers (bdd_xxx_hook) + + +VER 1.1 (april 1998) +-------------------- + + Added bdd_varprofile + + Added fdd_scanset + + Mucho better documentation. + + Added Henrik Reif Andersen's BDD notes to the documentation. + + Added BDD_REORDER_RANDOM for test purposes (usefull for others?) + x Fixed a bug in bdd_appex and bdd_appall. + x Fixed a bug in bdd_simplify. + x Speed fixup to fdd_extdomain + x Lots of small (insignificant?) bug fixes in fdd.c. + x bdd_load/save updated to take reordering into account. + x Generalized bdd_restrict to use a BDD variable set. + x Fixed the identifiers for the operator caches. + x The math functions log1p and pow2 has been removed as they didn't + exist on some systems. The same applies to M_LN2. + x New file structure and makefiles. + - Removed bdd_break, bdd_restart1 + + diff --git a/sdk/buddy-2.4/README b/sdk/buddy-2.4/README new file mode 100644 index 0000000..32d64e7 --- /dev/null +++ b/sdk/buddy-2.4/README @@ -0,0 +1,128 @@ +========================================================================== + *** BuDDy *** + Binary Decision Diagrams + Library Package v2.4 +-------------------------------------------------------------------------- + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================== + + +--------------------------------------------------------------------- +--- PREFACE -------------------------------------------------------- +--------------------------------------------------------------------- + +BuDDy was originally developed by Jorn Lind-Nielsen as a part of his +PhD thesis. +After using BuDDy as a BDD library for long time (while getting some +support from Jorn through email), I have been suggested by Jorn to take +ownership of the project and move it to SourceForge. +I invite all users who are interested to participate in the development +to contact me. (I always have desired tasks / features awaiting...) +I hope that BuDDy will prosper under my management. + +Haim Cohen +haimcohen@users.sourceforge.net + +--------------------------------------------------------------------- +--- REQUIREMENTS ---------------------------------------------------- +--------------------------------------------------------------------- + +* A (not too old) C++ compiler. I use g++ 3.3.3 +* A machine that supports 32 bit integers + + +--------------------------------------------------------------------- +--- INSTALLING ------------------------------------------------------ +--------------------------------------------------------------------- + +The following commands should build and install the library. + + ./configure + make + make install + +`./configure' accepts many arguments to tune your installation. +The following options are noteworthy: + + --includedir=/somewhere/include + Specify where header files will be installed. + + --libdir=/somewhere/lib + Specify where libraries will be installed. + + --disable-shared + Do not build the shared library for BuDDy. + + --disable-static + Do not build the static library for BuDDy. + + --enable-swap-count + Count number of fundamental variable swaps (for debugging) + + --enable-cache-stats + Gather statistical information about operator and unique node + caching (for debugging) + +Run `./configure --help' for a complete listing, and see +the INSTALL file for generic instructions. + +Some machines are missing "CLOCKS_PER_SEC". BuDDy will use +a default value of 60 on these. You can overwrite this setting +by setting DEFAULT_CLOCK as follows: + + ./configure CPPFLAGS=-DDEFAULT_CLOCK=1000 + +Part of the BuDDy library needs 64 bit arithmetics. With gnu C++, +Microsoft C++ and KAI C++, and any C99 compiler, this is part of the +language and used by BuDDy. With other compilers BuDDy need to +implement the math it self -- which is a bit slower. If you now of a +64 bit unsigned integer type on your platform then define that in the +BUDDYUINT64 variable. Example: + + ./configure CPPFLAGS=-DBUDDYUINT64="long long" + +Run `make check' to build the examples. +The examples also serve as a regression suite. + +--------------------------------------------------------------------- +--- USING ----------------------------------------------------------- +--------------------------------------------------------------------- + +Assuming that the files "bdd.h" and "libbdd.a" are in directories +"/usr/local/include" and "/usr/local/lib" then the compile command +could be: + + g++ -I/usr/local/include myfile.cc -o myfile -L/usr/local/lib -lbdd + +Your machine may be setup to use the above directories automatically, +so you might be able to do: + + g++ myfile.cc -o myfile -lbdd + + + diff --git a/sdk/buddy-2.4/aclocal.m4 b/sdk/buddy-2.4/aclocal.m4 new file mode 100644 index 0000000..a1e4ae4 --- /dev/null +++ b/sdk/buddy-2.4/aclocal.m4 @@ -0,0 +1,6861 @@ +# generated automatically by aclocal 1.8.5 -*- Autoconf -*- + +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 +# Free Software Foundation, Inc. +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- + +# serial 47 AC_PROG_LIBTOOL + + +# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ----------------------------------------------------------- +# If this macro is not defined by Autoconf, define it here. +m4_ifdef([AC_PROVIDE_IFELSE], + [], + [m4_define([AC_PROVIDE_IFELSE], + [m4_ifdef([AC_PROVIDE_$1], + [$2], [$3])])]) + + +# AC_PROG_LIBTOOL +# --------------- +AC_DEFUN([AC_PROG_LIBTOOL], +[AC_REQUIRE([_AC_PROG_LIBTOOL])dnl +dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX +dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX. + AC_PROVIDE_IFELSE([AC_PROG_CXX], + [AC_LIBTOOL_CXX], + [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX + ])]) +dnl And a similar setup for Fortran 77 support + AC_PROVIDE_IFELSE([AC_PROG_F77], + [AC_LIBTOOL_F77], + [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77 +])]) + +dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly. +dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run +dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both. + AC_PROVIDE_IFELSE([AC_PROG_GCJ], + [AC_LIBTOOL_GCJ], + [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], + [AC_LIBTOOL_GCJ], + [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ], + [AC_LIBTOOL_GCJ], + [ifdef([AC_PROG_GCJ], + [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])]) + ifdef([A][M_PROG_GCJ], + [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])]) + ifdef([LT_AC_PROG_GCJ], + [define([LT_AC_PROG_GCJ], + defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])]) +])])# AC_PROG_LIBTOOL + + +# _AC_PROG_LIBTOOL +# ---------------- +AC_DEFUN([_AC_PROG_LIBTOOL], +[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl +AC_BEFORE([$0],[AC_LIBTOOL_CXX])dnl +AC_BEFORE([$0],[AC_LIBTOOL_F77])dnl +AC_BEFORE([$0],[AC_LIBTOOL_GCJ])dnl + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl + +# Prevent multiple expansion +define([AC_PROG_LIBTOOL], []) +])# _AC_PROG_LIBTOOL + + +# AC_LIBTOOL_SETUP +# ---------------- +AC_DEFUN([AC_LIBTOOL_SETUP], +[AC_PREREQ(2.50)dnl +AC_REQUIRE([AC_ENABLE_SHARED])dnl +AC_REQUIRE([AC_ENABLE_STATIC])dnl +AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_LD])dnl +AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl +AC_REQUIRE([AC_PROG_NM])dnl + +AC_REQUIRE([AC_PROG_LN_S])dnl +AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl +# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers! +AC_REQUIRE([AC_OBJEXT])dnl +AC_REQUIRE([AC_EXEEXT])dnl +dnl + +AC_LIBTOOL_SYS_MAX_CMD_LEN +AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE +AC_LIBTOOL_OBJDIR + +AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl +_LT_AC_PROG_ECHO_BACKSLASH + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed='sed -e s/^X//' +[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g'] + +# Same as above, but do not quote variable references. +[double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g'] + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' + +# Constants: +rm="rm -f" + +# Global variables: +default_ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except M$VC, +# which needs '.lib'). +libext=a +ltmain="$ac_aux_dir/ltmain.sh" +ofile="$default_ofile" +with_gnu_ld="$lt_cv_prog_gnu_ld" + +AC_CHECK_TOOL(AR, ar, false) +AC_CHECK_TOOL(RANLIB, ranlib, :) +AC_CHECK_TOOL(STRIP, strip, :) + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$AR" && AR=ar +test -z "$AR_FLAGS" && AR_FLAGS=cru +test -z "$AS" && AS=as +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$DLLTOOL" && DLLTOOL=dlltool +test -z "$LD" && LD=ld +test -z "$LN_S" && LN_S="ln -s" +test -z "$MAGIC_CMD" && MAGIC_CMD=file +test -z "$NM" && NM=nm +test -z "$SED" && SED=sed +test -z "$OBJDUMP" && OBJDUMP=objdump +test -z "$RANLIB" && RANLIB=: +test -z "$STRIP" && STRIP=: +test -z "$ac_objext" && ac_objext=o + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds" + ;; + *) + old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib" +fi + +# Only perform the check for file, if the check method requires it +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + AC_PATH_MAGIC + fi + ;; +esac + +AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no) +AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL], +enable_win32_dll=yes, enable_win32_dll=no) + +AC_ARG_ENABLE([libtool-lock], + [AC_HELP_STRING([--disable-libtool-lock], + [avoid locking (might break parallel builds)])]) +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +AC_ARG_WITH([pic], + [AC_HELP_STRING([--with-pic], + [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], + [pic_mode="$withval"], + [pic_mode=default]) +test -z "$pic_mode" && pic_mode=default + +# Use C for the default configuration in the libtool script +tagname= +AC_LIBTOOL_LANG_C_CONFIG +_LT_AC_TAGCONFIG +])# AC_LIBTOOL_SETUP + + +# _LT_AC_SYS_COMPILER +# ------------------- +AC_DEFUN([_LT_AC_SYS_COMPILER], +[AC_REQUIRE([AC_PROG_CC])dnl + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC +])# _LT_AC_SYS_COMPILER + + +# _LT_AC_SYS_LIBPATH_AIX +# ---------------------- +# Links a minimal program and checks the executable +# for the system default hardcoded library path. In most cases, +# this is /usr/lib:/lib, but when the MPI compilers are used +# the location of the communication and MPI libs are included too. +# If we don't find anything, use the default library path according +# to the aix ld manual. +AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX], +[AC_LINK_IFELSE(AC_LANG_PROGRAM,[ +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi],[]) +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi +])# _LT_AC_SYS_LIBPATH_AIX + + +# _LT_AC_SHELL_INIT(ARG) +# ---------------------- +AC_DEFUN([_LT_AC_SHELL_INIT], +[ifdef([AC_DIVERSION_NOTICE], + [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)], + [AC_DIVERT_PUSH(NOTICE)]) +$1 +AC_DIVERT_POP +])# _LT_AC_SHELL_INIT + + +# _LT_AC_PROG_ECHO_BACKSLASH +# -------------------------- +# Add some code to the start of the generated configure script which +# will find an echo command which doesn't interpret backslashes. +AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH], +[_LT_AC_SHELL_INIT([ +# Check that we are running under the correct shell. +SHELL=${CONFIG_SHELL-/bin/sh} + +case X$ECHO in +X*--fallback-echo) + # Remove one level of quotation (which was required for Make). + ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','` + ;; +esac + +echo=${ECHO-echo} +if test "X[$]1" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift +elif test "X[$]1" = X--fallback-echo; then + # Avoid inline document here, it may be left over + : +elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then + # Yippee, $echo works! + : +else + # Restart under the correct shell. + exec $SHELL "[$]0" --no-reexec ${1+"[$]@"} +fi + +if test "X[$]1" = X--fallback-echo; then + # used as fallback echo + shift + cat </dev/null && + echo_test_string="`eval $cmd`" && + (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null + then + break + fi + done +fi + +if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + : +else + # The Solaris, AIX, and Digital Unix default echo programs unquote + # backslashes. This makes it impossible to quote backslashes using + # echo "$something" | sed 's/\\/\\\\/g' + # + # So, first we look for a working echo in the user's PATH. + + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for dir in $PATH /usr/ucb; do + IFS="$lt_save_ifs" + if (test -f $dir/echo || test -f $dir/echo$ac_exeext) && + test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + echo="$dir/echo" + break + fi + done + IFS="$lt_save_ifs" + + if test "X$echo" = Xecho; then + # We didn't find a better echo, so look for alternatives. + if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + # This shell has a builtin print -r that does the trick. + echo='print -r' + elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) && + test "X$CONFIG_SHELL" != X/bin/ksh; then + # If we have ksh, try running configure again with it. + ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} + export ORIGINAL_CONFIG_SHELL + CONFIG_SHELL=/bin/ksh + export CONFIG_SHELL + exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"} + else + # Try using printf. + echo='printf %s\n' + if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + # Cool, printf works + : + elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` && + test "X$echo_testing_string" = 'X\t' && + echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL + export CONFIG_SHELL + SHELL="$CONFIG_SHELL" + export SHELL + echo="$CONFIG_SHELL [$]0 --fallback-echo" + elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` && + test "X$echo_testing_string" = 'X\t' && + echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + echo="$CONFIG_SHELL [$]0 --fallback-echo" + else + # maybe with a smaller string... + prev=: + + for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do + if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null + then + break + fi + prev="$cmd" + done + + if test "$prev" != 'sed 50q "[$]0"'; then + echo_test_string=`eval $prev` + export echo_test_string + exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"} + else + # Oops. We lost completely, so just stick with echo. + echo=echo + fi + fi + fi + fi +fi +fi + +# Copy echo and quote the copy suitably for passing to libtool from +# the Makefile, instead of quoting the original, which is used later. +ECHO=$echo +if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then + ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo" +fi + +AC_SUBST(ECHO) +])])# _LT_AC_PROG_ECHO_BACKSLASH + + +# _LT_AC_LOCK +# ----------- +AC_DEFUN([_LT_AC_LOCK], +[AC_ARG_ENABLE([libtool-lock], + [AC_HELP_STRING([--disable-libtool-lock], + [avoid locking (might break parallel builds)])]) +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '[#]line __oline__ "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + lt_cv_cc_lib64_suffix=no + if AC_TRY_EVAL(ac_compile); then + case "`/usr/bin/file conftest.$ac_objext`" in + *32-bit*) + case $host in + x86_64-*linux*) + LD="${LD-ld} -m elf_i386" + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + lt_cv_cc_lib64_suffix=yes + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + lt_cv_cc_lib64_suffix=yes + ;; + s390*-*linux*) + LD="${LD-ld} -m elf64_s390" + lt_cv_cc_lib64_suffix=yes + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + lt_cv_cc_lib64_suffix=yes + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, + [AC_LANG_PUSH(C) + AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) + AC_LANG_POP]) + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL], +[*-*-cygwin* | *-*-mingw* | *-*-pw32*) + AC_CHECK_TOOL(DLLTOOL, dlltool, false) + AC_CHECK_TOOL(AS, as, false) + AC_CHECK_TOOL(OBJDUMP, objdump, false) + ;; + ]) +esac + +need_locks="$enable_libtool_lock" + +])# _LT_AC_LOCK + + +# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------------------- +# Check whether the given compiler option works +AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], +[AC_REQUIRE([LT_AC_PROG_SED]) +AC_CACHE_CHECK([$1], [$2], + [$2=no + ifelse([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$3" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + $2=yes + fi + fi + $rm conftest* +]) + +if test x"[$]$2" = xyes; then + ifelse([$5], , :, [$5]) +else + ifelse([$6], , :, [$6]) +fi +])# AC_LIBTOOL_COMPILER_OPTION + + +# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [ACTION-SUCCESS], [ACTION-FAILURE]) +# ------------------------------------------------------------ +# Check whether the given compiler option works +AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], +[AC_CACHE_CHECK([$1], [$2], + [$2=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $3" + printf "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&AS_MESSAGE_LOG_FD + else + $2=yes + fi + fi + $rm conftest* + LDFLAGS="$save_LDFLAGS" +]) + +if test x"[$]$2" = xyes; then + ifelse([$4], , :, [$4]) +else + ifelse([$5], , :, [$5]) +fi +])# AC_LIBTOOL_LINKER_OPTION + + +# AC_LIBTOOL_SYS_MAX_CMD_LEN +# -------------------------- +AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], +[# find the maximum length of command line arguments +AC_MSG_CHECKING([the maximum length of command line arguments]) +AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + *) + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while (test "X"`$CONFIG_SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \ + = "XX$teststring") >/dev/null 2>&1 && + new_result=`expr "X$teststring" : ".*" 2>&1` && + lt_cv_sys_max_cmd_len=$new_result && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + teststring= + # Add a significant safety factor because C++ compilers can tack on massive + # amounts of additional arguments before passing them to the linker. + # It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + ;; + esac +]) +if test -n $lt_cv_sys_max_cmd_len ; then + AC_MSG_RESULT($lt_cv_sys_max_cmd_len) +else + AC_MSG_RESULT(none) +fi +])# AC_LIBTOOL_SYS_MAX_CMD_LEN + + +# _LT_AC_CHECK_DLFCN +# -------------------- +AC_DEFUN([_LT_AC_CHECK_DLFCN], +[AC_CHECK_HEADERS(dlfcn.h)dnl +])# _LT_AC_CHECK_DLFCN + + +# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, +# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) +# ------------------------------------------------------------------ +AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF], +[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl +if test "$cross_compiling" = yes; then : + [$4] +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +}] +EOF + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) $1 ;; + x$lt_dlneed_uscore) $2 ;; + x$lt_unknown|x*) $3 ;; + esac + else : + # compilation failed + $3 + fi +fi +rm -fr conftest* +])# _LT_AC_TRY_DLOPEN_SELF + + +# AC_LIBTOOL_DLOPEN_SELF +# ------------------- +AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], +[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ]) + ;; + + *) + AC_CHECK_FUNC([shl_load], + [lt_cv_dlopen="shl_load"], + [AC_CHECK_LIB([dld], [shl_load], + [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"], + [AC_CHECK_FUNC([dlopen], + [lt_cv_dlopen="dlopen"], + [AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], + [AC_CHECK_LIB([svld], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], + [AC_CHECK_LIB([dld], [dld_link], + [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"]) + ]) + ]) + ]) + ]) + ]) + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + AC_CACHE_CHECK([whether a program can dlopen itself], + lt_cv_dlopen_self, [dnl + _LT_AC_TRY_DLOPEN_SELF( + lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, + lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) + ]) + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + AC_CACHE_CHECK([whether a statically linked program can dlopen itself], + lt_cv_dlopen_self_static, [dnl + _LT_AC_TRY_DLOPEN_SELF( + lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, + lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) + ]) + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi +])# AC_LIBTOOL_DLOPEN_SELF + + +# AC_LIBTOOL_PROG_CC_C_O([TAGNAME]) +# --------------------------------- +# Check to see if options -c and -o are simultaneously supported by compiler +AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O], +[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl +AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], + [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)], + [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* +]) +])# AC_LIBTOOL_PROG_CC_C_O + + +# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME]) +# ----------------------------------------- +# Check to see if we can do hard links to lock some files if needed +AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], +[AC_REQUIRE([_LT_AC_LOCK])dnl + +hard_links="nottested" +if test "$_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + AC_MSG_CHECKING([if we can lock with hard links]) + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + AC_MSG_RESULT([$hard_links]) + if test "$hard_links" = no; then + AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) + need_locks=warn + fi +else + need_locks=no +fi +])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS + + +# AC_LIBTOOL_OBJDIR +# ----------------- +AC_DEFUN([AC_LIBTOOL_OBJDIR], +[AC_CACHE_CHECK([for objdir], [lt_cv_objdir], +[rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null]) +objdir=$lt_cv_objdir +])# AC_LIBTOOL_OBJDIR + + +# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME]) +# ---------------------------------------------- +# Check hardcoding attributes. +AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], +[AC_MSG_CHECKING([how to hardcode library paths into programs]) +_LT_AC_TAGVAR(hardcode_action, $1)= +if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \ + test -n "$_LT_AC_TAGVAR(runpath_var $1)" || \ + test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no && + test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then + # Linking always hardcodes the temporary library directory. + _LT_AC_TAGVAR(hardcode_action, $1)=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + _LT_AC_TAGVAR(hardcode_action, $1)=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + _LT_AC_TAGVAR(hardcode_action, $1)=unsupported +fi +AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)]) + +if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi +])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH + + +# AC_LIBTOOL_SYS_LIB_STRIP +# ------------------------ +AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP], +[striplib= +old_striplib= +AC_MSG_CHECKING([whether stripping libraries is possible]) +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + AC_MSG_RESULT([yes]) +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) +fi + ;; + *) + AC_MSG_RESULT([no]) + ;; + esac +fi +])# AC_LIBTOOL_SYS_LIB_STRIP + + +# AC_LIBTOOL_SYS_DYNAMIC_LINKER +# ----------------------------- +# PORTME Fill in your ld.so characteristics +AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER], +[AC_MSG_CHECKING([dynamic linker characteristics]) +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[[01]] | aix4.[[01]].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | [grep ';[c-zC-Z]:/' >/dev/null]; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/[:,\t]/ /g;s/=[^=]*$//;s/=[^= ]* / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[[89]] | openbsd2.[[89]].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +AC_MSG_RESULT([$dynamic_linker]) +test "$dynamic_linker" = no && can_build_shared=no +])# AC_LIBTOOL_SYS_DYNAMIC_LINKER + + +# _LT_AC_TAGCONFIG +# ---------------- +AC_DEFUN([_LT_AC_TAGCONFIG], +[AC_ARG_WITH([tags], + [AC_HELP_STRING([--with-tags@<:@=TAGS@:>@], + [include additional configurations @<:@automatic@:>@])], + [tagnames="$withval"]) + +if test -f "$ltmain" && test -n "$tagnames"; then + if test ! -f "${ofile}"; then + AC_MSG_WARN([output file `$ofile' does not exist]) + fi + + if test -z "$LTCC"; then + eval "`$SHELL ${ofile} --config | grep '^LTCC='`" + if test -z "$LTCC"; then + AC_MSG_WARN([output file `$ofile' does not look like a libtool script]) + else + AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile']) + fi + fi + + # Extract list of available tagged configurations in $ofile. + # Note that this assumes the entire list is on one line. + available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'` + + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for tagname in $tagnames; do + IFS="$lt_save_ifs" + # Check whether tagname contains only valid characters + case `$echo "X$tagname" | $Xsed -e 's:[[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]]::g'` in + "") ;; + *) AC_MSG_ERROR([invalid tag name: $tagname]) + ;; + esac + + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null + then + AC_MSG_ERROR([tag name \"$tagname\" already exists]) + fi + + # Update the list of available tags. + if test -n "$tagname"; then + echo appending configuration tag \"$tagname\" to $ofile + + case $tagname in + CXX) + if test -n "$CXX" && test "X$CXX" != "Xno"; then + AC_LIBTOOL_LANG_CXX_CONFIG + else + tagname="" + fi + ;; + + F77) + if test -n "$F77" && test "X$F77" != "Xno"; then + AC_LIBTOOL_LANG_F77_CONFIG + else + tagname="" + fi + ;; + + GCJ) + if test -n "$GCJ" && test "X$GCJ" != "Xno"; then + AC_LIBTOOL_LANG_GCJ_CONFIG + else + tagname="" + fi + ;; + + RC) + AC_LIBTOOL_LANG_RC_CONFIG + ;; + + *) + AC_MSG_ERROR([Unsupported tag name: $tagname]) + ;; + esac + + # Append the new tag name to the list of available tags. + if test -n "$tagname" ; then + available_tags="$available_tags $tagname" + fi + fi + done + IFS="$lt_save_ifs" + + # Now substitute the updated list of available tags. + if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then + mv "${ofile}T" "$ofile" + chmod +x "$ofile" + else + rm -f "${ofile}T" + AC_MSG_ERROR([unable to update list of available tagged configurations.]) + fi +fi +])# _LT_AC_TAGCONFIG + + +# AC_LIBTOOL_DLOPEN +# ----------------- +# enable checks for dlopen support +AC_DEFUN([AC_LIBTOOL_DLOPEN], + [AC_BEFORE([$0],[AC_LIBTOOL_SETUP]) +])# AC_LIBTOOL_DLOPEN + + +# AC_LIBTOOL_WIN32_DLL +# -------------------- +# declare package support for building win32 dll's +AC_DEFUN([AC_LIBTOOL_WIN32_DLL], +[AC_BEFORE([$0], [AC_LIBTOOL_SETUP]) +])# AC_LIBTOOL_WIN32_DLL + + +# AC_ENABLE_SHARED([DEFAULT]) +# --------------------------- +# implement the --enable-shared flag +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +AC_DEFUN([AC_ENABLE_SHARED], +[define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE([shared], + [AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@], + [build shared libraries @<:@default=]AC_ENABLE_SHARED_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_shared=]AC_ENABLE_SHARED_DEFAULT) +])# AC_ENABLE_SHARED + + +# AC_DISABLE_SHARED +# ----------------- +#- set the default shared flag to --disable-shared +AC_DEFUN([AC_DISABLE_SHARED], +[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +AC_ENABLE_SHARED(no) +])# AC_DISABLE_SHARED + + +# AC_ENABLE_STATIC([DEFAULT]) +# --------------------------- +# implement the --enable-static flag +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +AC_DEFUN([AC_ENABLE_STATIC], +[define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE([static], + [AC_HELP_STRING([--enable-static@<:@=PKGS@:>@], + [build static libraries @<:@default=]AC_ENABLE_STATIC_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_static=]AC_ENABLE_STATIC_DEFAULT) +])# AC_ENABLE_STATIC + + +# AC_DISABLE_STATIC +# ----------------- +# set the default static flag to --disable-static +AC_DEFUN([AC_DISABLE_STATIC], +[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +AC_ENABLE_STATIC(no) +])# AC_DISABLE_STATIC + + +# AC_ENABLE_FAST_INSTALL([DEFAULT]) +# --------------------------------- +# implement the --enable-fast-install flag +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +AC_DEFUN([AC_ENABLE_FAST_INSTALL], +[define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE([fast-install], + [AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], + [optimize for fast installation @<:@default=]AC_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_fast_install=]AC_ENABLE_FAST_INSTALL_DEFAULT) +])# AC_ENABLE_FAST_INSTALL + + +# AC_DISABLE_FAST_INSTALL +# ----------------------- +# set the default to --disable-fast-install +AC_DEFUN([AC_DISABLE_FAST_INSTALL], +[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +AC_ENABLE_FAST_INSTALL(no) +])# AC_DISABLE_FAST_INSTALL + + +# AC_LIBTOOL_PICMODE([MODE]) +# -------------------------- +# implement the --with-pic flag +# MODE is either `yes' or `no'. If omitted, it defaults to `both'. +AC_DEFUN([AC_LIBTOOL_PICMODE], +[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl +pic_mode=ifelse($#,1,$1,default) +])# AC_LIBTOOL_PICMODE + + +# AC_PROG_EGREP +# ------------- +# This is predefined starting with Autoconf 2.54, so this conditional +# definition can be removed once we require Autoconf 2.54 or later. +m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP], +[AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep], + [if echo a | (grep -E '(a|b)') >/dev/null 2>&1 + then ac_cv_prog_egrep='grep -E' + else ac_cv_prog_egrep='egrep' + fi]) + EGREP=$ac_cv_prog_egrep + AC_SUBST([EGREP]) +])]) + + +# AC_PATH_TOOL_PREFIX +# ------------------- +# find a file program which can recognise shared library +AC_DEFUN([AC_PATH_TOOL_PREFIX], +[AC_REQUIRE([AC_PROG_EGREP])dnl +AC_MSG_CHECKING([for $1]) +AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, +[case $MAGIC_CMD in +[[\\/*] | ?:[\\/]*]) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR +dnl $ac_dummy forces splitting on constant user-supplied paths. +dnl POSIX.2 word splitting is done only on the output of word expansions, +dnl not every word. This closes a longstanding sh security hole. + ac_dummy="ifelse([$2], , $PATH, [$2])" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$1; then + lt_cv_path_MAGIC_CMD="$ac_dir/$1" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac]) +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + AC_MSG_RESULT($MAGIC_CMD) +else + AC_MSG_RESULT(no) +fi +])# AC_PATH_TOOL_PREFIX + + +# AC_PATH_MAGIC +# ------------- +# find a file program which can recognise a shared library +AC_DEFUN([AC_PATH_MAGIC], +[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) + else + MAGIC_CMD=: + fi +fi +])# AC_PATH_MAGIC + + +# AC_PROG_LD +# ---------- +# find the pathname to the GNU or non-GNU linker +AC_DEFUN([AC_PROG_LD], +[AC_ARG_WITH([gnu-ld], + [AC_HELP_STRING([--with-gnu-ld], + [assume the C compiler uses GNU ld @<:@default=no@:>@])], + [test "$withval" = no || with_gnu_ld=yes], + [with_gnu_ld=no]) +AC_REQUIRE([LT_AC_PROG_SED])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by $CC]) + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [[\\/]]* | ?:[[\\/]]*) + re_direlt='/[[^/]][[^/]]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'` + while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do + ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +AC_CACHE_VAL(lt_cv_path_LD, +[if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some GNU ld's only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[[3-9]]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case "$host_cpu" in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]'] + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be Linux ELF. +linux*) + case $host_cpu in + alpha*|hppa*|i*86|ia64*|m68*|mips*|powerpc*|sparc*|s390*|sh*|x86_64*) + lt_cv_deplibs_check_method=pass_all ;; + *) + # glibc up to 2.1.1 does not perform some relocations on ARM + # this will be overridden with pass_all, but let us keep it just in case + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;; + esac + lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so` + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +nto-qnx*) + lt_cv_deplibs_check_method=unknown + ;; + +openbsd*) + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object' + else + lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +sco3.2v5*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; +esac +]) +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown +])# AC_DEPLIBS_CHECK_METHOD + + +# AC_PROG_NM +# ---------- +# find the pathname to a BSD-compatible name lister +AC_DEFUN([AC_PROG_NM], +[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM, +[if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/${ac_tool_prefix}nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + esac + fi + done + IFS="$lt_save_ifs" + test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm +fi]) +NM="$lt_cv_path_NM" +])# AC_PROG_NM + + +# AC_CHECK_LIBM +# ------------- +# check for math library +AC_DEFUN([AC_CHECK_LIBM], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +LIBM= +case $host in +*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*) + # These system don't have libm, or don't need it + ;; +*-ncr-sysv4.3*) + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") + AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") + ;; +*) + AC_CHECK_LIB(m, cos, LIBM="-lm") + ;; +esac +])# AC_CHECK_LIBM + + +# AC_LIBLTDL_CONVENIENCE([DIRECTORY]) +# ----------------------------------- +# sets LIBLTDL to the link flags for the libltdl convenience library and +# LTDLINCL to the include flags for the libltdl header and adds +# --enable-ltdl-convenience to the configure arguments. Note that LIBLTDL +# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If +# DIRECTORY is not provided, it is assumed to be `libltdl'. LIBLTDL will +# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed with +# '${top_srcdir}/' (note the single quotes!). If your package is not +# flat and you're not using automake, define top_builddir and +# top_srcdir appropriately in the Makefiles. +AC_DEFUN([AC_LIBLTDL_CONVENIENCE], +[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl + case $enable_ltdl_convenience in + no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;; + "") enable_ltdl_convenience=yes + ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;; + esac + LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la + LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl']) + # For backwards non-gettext consistent compatibility... + INCLTDL="$LTDLINCL" +])# AC_LIBLTDL_CONVENIENCE + + +# AC_LIBLTDL_INSTALLABLE([DIRECTORY]) +# ----------------------------------- +# sets LIBLTDL to the link flags for the libltdl installable library and +# LTDLINCL to the include flags for the libltdl header and adds +# --enable-ltdl-install to the configure arguments. Note that LIBLTDL +# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If +# DIRECTORY is not provided and an installed libltdl is not found, it is +# assumed to be `libltdl'. LIBLTDL will be prefixed with '${top_builddir}/' +# and LTDLINCL will be prefixed with '${top_srcdir}/' (note the single +# quotes!). If your package is not flat and you're not using automake, +# define top_builddir and top_srcdir appropriately in the Makefiles. +# In the future, this macro may have to be called after AC_PROG_LIBTOOL. +AC_DEFUN([AC_LIBLTDL_INSTALLABLE], +[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl + AC_CHECK_LIB(ltdl, lt_dlinit, + [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no], + [if test x"$enable_ltdl_install" = xno; then + AC_MSG_WARN([libltdl not installed, but installation disabled]) + else + enable_ltdl_install=yes + fi + ]) + if test x"$enable_ltdl_install" = x"yes"; then + ac_configure_args="$ac_configure_args --enable-ltdl-install" + LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdl.la + LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl']) + else + ac_configure_args="$ac_configure_args --enable-ltdl-install=no" + LIBLTDL="-lltdl" + LTDLINCL= + fi + # For backwards non-gettext consistent compatibility... + INCLTDL="$LTDLINCL" +])# AC_LIBLTDL_INSTALLABLE + + +# AC_LIBTOOL_CXX +# -------------- +# enable support for C++ libraries +AC_DEFUN([AC_LIBTOOL_CXX], +[AC_REQUIRE([_LT_AC_LANG_CXX]) +])# AC_LIBTOOL_CXX + + +# _LT_AC_LANG_CXX +# --------------- +AC_DEFUN([_LT_AC_LANG_CXX], +[AC_REQUIRE([AC_PROG_CXX]) +AC_REQUIRE([AC_PROG_CXXCPP]) +_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX]) +])# _LT_AC_LANG_CXX + + +# AC_LIBTOOL_F77 +# -------------- +# enable support for Fortran 77 libraries +AC_DEFUN([AC_LIBTOOL_F77], +[AC_REQUIRE([_LT_AC_LANG_F77]) +])# AC_LIBTOOL_F77 + + +# _LT_AC_LANG_F77 +# --------------- +AC_DEFUN([_LT_AC_LANG_F77], +[AC_REQUIRE([AC_PROG_F77]) +_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}F77]) +])# _LT_AC_LANG_F77 + + +# AC_LIBTOOL_GCJ +# -------------- +# enable support for GCJ libraries +AC_DEFUN([AC_LIBTOOL_GCJ], +[AC_REQUIRE([_LT_AC_LANG_GCJ]) +])# AC_LIBTOOL_GCJ + + +# _LT_AC_LANG_GCJ +# --------------- +AC_DEFUN([_LT_AC_LANG_GCJ], +[AC_PROVIDE_IFELSE([AC_PROG_GCJ],[], + [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],[], + [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],[], + [ifdef([AC_PROG_GCJ],[AC_REQUIRE([AC_PROG_GCJ])], + [ifdef([A][M_PROG_GCJ],[AC_REQUIRE([A][M_PROG_GCJ])], + [AC_REQUIRE([A][C_PROG_GCJ_OR_A][M_PROG_GCJ])])])])])]) +_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}GCJ]) +])# _LT_AC_LANG_GCJ + + +# AC_LIBTOOL_RC +# -------------- +# enable support for Windows resource files +AC_DEFUN([AC_LIBTOOL_RC], +[AC_REQUIRE([LT_AC_PROG_RC]) +_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}RC]) +])# AC_LIBTOOL_RC + + +# AC_LIBTOOL_LANG_C_CONFIG +# ------------------------ +# Ensure that the configuration vars for the C compiler are +# suitably defined. Those variables are subsequently used by +# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'. +AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG], [_LT_AC_LANG_C_CONFIG]) +AC_DEFUN([_LT_AC_LANG_C_CONFIG], +[lt_save_CC="$CC" +AC_LANG_PUSH(C) + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +_LT_AC_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}\n' + +_LT_AC_SYS_COMPILER + +# +# Check for any special shared library compilation flags. +# +_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)= +if test "$GCC" = no; then + case $host_os in + sco3.2v5*) + _LT_AC_TAGVAR(lt_prog_cc_shlib, $1)='-belf' + ;; + esac +fi +if test -n "$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)"; then + AC_MSG_WARN([`$CC' requires `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to build shared libraries]) + if echo "$old_CC $old_CFLAGS " | grep "[[ ]]$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)[[ ]]" >/dev/null; then : + else + AC_MSG_WARN([add `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to the CC or CFLAGS env variable and reconfigure]) + _LT_AC_TAGVAR(lt_cv_prog_cc_can_build_shared, $1)=no + fi +fi + + +# +# Check to make sure the static flag actually works. +# +AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $_LT_AC_TAGVAR(lt_prog_compiler_static, $1) works], + _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1), + $_LT_AC_TAGVAR(lt_prog_compiler_static, $1), + [], + [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=]) + + +AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1) +AC_LIBTOOL_PROG_COMPILER_PIC($1) +AC_LIBTOOL_PROG_CC_C_O($1) +AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1) +AC_LIBTOOL_PROG_LD_SHLIBS($1) +AC_LIBTOOL_SYS_DYNAMIC_LINKER($1) +AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1) +AC_LIBTOOL_SYS_LIB_STRIP +AC_LIBTOOL_DLOPEN_SELF($1) + +# Report which librarie types wil actually be built +AC_MSG_CHECKING([if libtool supports shared libraries]) +AC_MSG_RESULT([$can_build_shared]) + +AC_MSG_CHECKING([whether to build shared libraries]) +test "$can_build_shared" = "no" && enable_shared=no + +# On AIX, shared libraries and static libraries use the same namespace, and +# are all built from PIC. +case "$host_os" in +aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + +aix4* | aix5*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + darwin* | rhapsody*) + if test "$GCC" = yes; then + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + case "$host_os" in + rhapsody* | darwin1.[[012]]) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[[012]]) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress' + ;; + 10.*) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + output_verbose_link_cmd='echo' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring' + _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_automatic, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience' + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; +esac +AC_MSG_RESULT([$enable_shared]) + +AC_MSG_CHECKING([whether to build static libraries]) +# Make sure either enable_shared or enable_static is yes. +test "$enable_shared" = yes || enable_static=yes +AC_MSG_RESULT([$enable_static]) + +AC_LIBTOOL_CONFIG($1) + +AC_LANG_POP +CC="$lt_save_CC" +])# AC_LIBTOOL_LANG_C_CONFIG + + +# AC_LIBTOOL_LANG_CXX_CONFIG +# -------------------------- +# Ensure that the configuration vars for the C compiler are +# suitably defined. Those variables are subsequently used by +# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'. +AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG], [_LT_AC_LANG_CXX_CONFIG(CXX)]) +AC_DEFUN([_LT_AC_LANG_CXX_CONFIG], +[AC_LANG_PUSH(C++) +AC_REQUIRE([AC_PROG_CXX]) +AC_REQUIRE([AC_PROG_CXXCPP]) + +_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_AC_TAGVAR(allow_undefined_flag, $1)= +_LT_AC_TAGVAR(always_export_symbols, $1)=no +_LT_AC_TAGVAR(archive_expsym_cmds, $1)= +_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_AC_TAGVAR(hardcode_direct, $1)=no +_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)= +_LT_AC_TAGVAR(hardcode_libdir_separator, $1)= +_LT_AC_TAGVAR(hardcode_minus_L, $1)=no +_LT_AC_TAGVAR(hardcode_automatic, $1)=no +_LT_AC_TAGVAR(module_cmds, $1)= +_LT_AC_TAGVAR(module_expsym_cmds, $1)= +_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown +_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_AC_TAGVAR(no_undefined_flag, $1)= +_LT_AC_TAGVAR(whole_archive_flag_spec, $1)= +_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Dependencies to place before and after the object being linked: +_LT_AC_TAGVAR(predep_objects, $1)= +_LT_AC_TAGVAR(postdep_objects, $1)= +_LT_AC_TAGVAR(predeps, $1)= +_LT_AC_TAGVAR(postdeps, $1)= +_LT_AC_TAGVAR(compiler_lib_search_path, $1)= + +# Source file extension for C++ test sources. +ac_ext=cc + +# Object file extension for compiled C++ test sources. +objext=o +_LT_AC_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_AC_SYS_COMPILER + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_LD=$LD +lt_save_GCC=$GCC +GCC=$GXX +lt_save_with_gnu_ld=$with_gnu_ld +lt_save_path_LD=$lt_cv_path_LD +if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx +else + unset lt_cv_prog_gnu_ld +fi +if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX +else + unset lt_cv_path_LD +fi +test -z "${LDCXX+set}" || LD=$LDCXX +CC=${CXX-"c++"} +compiler=$CC +_LT_AC_TAGVAR(compiler, $1)=$CC +cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'` + +# We don't want -fno-exception wen compiling C++ code, so set the +# no_builtin_flag separately +if test "$GXX" = yes; then + _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' +else + _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= +fi + +if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + AC_PROG_LD + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | \ + grep 'no-whole-archive' > /dev/null; then + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + +else + GXX=no + with_gnu_ld=no + wlarc= +fi + +# PORTME: fill in a description of your system's C++ link characteristics +AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) +_LT_AC_TAGVAR(ld_shlibs, $1)=yes +case $host_os in + aix3*) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_AC_TAGVAR(archive_cmds, $1)='' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + + if test "$GXX" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + else + # We have old collect2 + _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + _LT_AC_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an empty executable. + _LT_AC_SYS_LIBPATH_AIX + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + _LT_AC_SYS_LIBPATH_AIX + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + _LT_AC_TAGVAR(always_export_symbols, $1)=yes + # Exported symbols can be pulled into shared objects from archives + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' ' + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds it's shared libraries. + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_AC_TAGVAR(always_export_symbols, $1)=no + _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes; then + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + case "$host_os" in + rhapsody* | darwin1.[[012]]) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[[012]]) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress' + ;; + 10.*) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + _LT_AC_TAGVAR(module_cmds, $1)='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_automatic, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience' + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + dgux*) + case $cc_basename in + ec++) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + ghcx) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + freebsd[12]*) + # C++ shared libraries reported to be fairly broken before switch to ELF + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + freebsd-elf*) + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + ;; + freebsd* | kfreebsd*-gnu) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + _LT_AC_TAGVAR(ld_shlibs, $1)=yes + ;; + gnu*) + ;; + hpux9*) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + aCC) + _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "[-]L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes; then + _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + case "$host_cpu" in + hppa*64*) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + ia64*) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + ;; + *) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + esac + fi + case "$host_cpu" in + hppa*64*) + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + ia64*) + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + *) + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + aCC) + case "$host_cpu" in + hppa*64*|ia64*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs' + ;; + *) + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case "$host_cpu" in + ia64*|hppa*64*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs' + ;; + *) + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + irix5* | irix6*) + case $cc_basename in + CC) + # SGI C++ + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib' + fi + fi + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + ;; + esac + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + linux*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath,$libdir' + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc) + # Intel C++ + with_gnu_ld=yes + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + cxx) + # Compaq C++ + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + esac + ;; + lynxos*) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + m88k*) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + mvs*) + case $cc_basename in + cxx) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + osf3*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' + + ;; + RCC) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + cxx) + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + + else + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + osf4* | osf5*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' + ;; + RCC) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + cxx) + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp `test -n "$verstring" && echo -set_version $verstring` -update_registry $objdir/so_locations -o $lib~ + $rm $lib.exp' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + + else + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + psos*) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + sco*) + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + lcc) + # Lucid + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + solaris*) + case $cc_basename in + CC) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The C++ compiler is used as linker so we must use $wl + # flag to pass the commands to the underlying system + # linker. + # Supported since Solaris 2.6 (maybe 2.5.1?) + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep "\-[[LR]]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + gcx) + # Green Hills C++ Compiler + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' + if $CC --version | grep -v '^2\.7' > /dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\"" + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\"" + fi + + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' + fi + ;; + esac + ;; + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*) + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + ;; + tandem*) + case $cc_basename in + NCC) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + vxworks*) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; +esac +AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)]) +test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + +_LT_AC_TAGVAR(GCC, $1)="$GXX" +_LT_AC_TAGVAR(LD, $1)="$LD" + +AC_LIBTOOL_POSTDEP_PREDEP($1) +AC_LIBTOOL_PROG_COMPILER_PIC($1) +AC_LIBTOOL_PROG_CC_C_O($1) +AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1) +AC_LIBTOOL_PROG_LD_SHLIBS($1) +AC_LIBTOOL_SYS_DYNAMIC_LINKER($1) +AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1) +AC_LIBTOOL_SYS_LIB_STRIP +AC_LIBTOOL_DLOPEN_SELF($1) + +AC_LIBTOOL_CONFIG($1) + +AC_LANG_POP +CC=$lt_save_CC +LDCXX=$LD +LD=$lt_save_LD +GCC=$lt_save_GCC +with_gnu_ldcxx=$with_gnu_ld +with_gnu_ld=$lt_save_with_gnu_ld +lt_cv_path_LDCXX=$lt_cv_path_LD +lt_cv_path_LD=$lt_save_path_LD +lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld +lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +])# AC_LIBTOOL_LANG_CXX_CONFIG + +# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME]) +# ------------------------ +# Figure out "hidden" library dependencies from verbose +# compiler output when linking a shared library. +# Parse the compiler output and extract the necessary +# objects, libraries and library flags. +AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[ +dnl we can't use the lt_simple_compile_test_code here, +dnl because it contains code intended for an executable, +dnl not a library. It's possible we should let each +dnl tag define a new lt_????_link_test_code variable, +dnl but it's only used here... +ifelse([$1],[],[cat > conftest.$ac_ext < conftest.$ac_ext < conftest.$ac_ext < conftest.$ac_ext <> "$cfgfile" +ifelse([$1], [], +[#! $SHELL + +# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP) +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 +# Free Software Foundation, Inc. +# +# This file is part of GNU Libtool: +# Originally by Gordon Matzigkeit , 1996 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="$SED -e s/^X//" + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi + +# The names of the tagged configurations supported by this script. +available_tags= + +# ### BEGIN LIBTOOL CONFIG], +[# ### BEGIN LIBTOOL TAG CONFIG: $tagname]) + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$_LT_AC_TAGVAR(archive_cmds_need_lc, $1) + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1) + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_[]_LT_AC_TAGVAR(compiler, $1) + +# Is the compiler the GNU C compiler? +with_gcc=$_LT_AC_TAGVAR(GCC, $1) + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_[]_LT_AC_TAGVAR(LD, $1) + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_wl, $1) + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_[]_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1) + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_static, $1) + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_[]_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_[]_LT_AC_TAGVAR(export_dynamic_flag_spec, $1) + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_[]_LT_AC_TAGVAR(whole_archive_flag_spec, $1) + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_[]_LT_AC_TAGVAR(thread_safe_flag_spec, $1) + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_cmds, $1) +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_new_cmds, $1) + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_[]_LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) + +# Commands used to build and install a shared archive. +archive_cmds=$lt_[]_LT_AC_TAGVAR(archive_cmds, $1) +archive_expsym_cmds=$lt_[]_LT_AC_TAGVAR(archive_expsym_cmds, $1) +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_[]_LT_AC_TAGVAR(module_cmds, $1) +module_expsym_cmds=$lt_[]_LT_AC_TAGVAR(module_expsym_cmds, $1) + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_[]_LT_AC_TAGVAR(predep_objects, $1) + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_[]_LT_AC_TAGVAR(postdep_objects, $1) + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_[]_LT_AC_TAGVAR(predeps, $1) + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_[]_LT_AC_TAGVAR(postdeps, $1) + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_[]_LT_AC_TAGVAR(compiler_lib_search_path, $1) + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_[]_LT_AC_TAGVAR(allow_undefined_flag, $1) + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_[]_LT_AC_TAGVAR(no_undefined_flag, $1) + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$_LT_AC_TAGVAR(hardcode_action, $1) + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1) + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_[]_LT_AC_TAGVAR(hardcode_libdir_separator, $1) + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$_LT_AC_TAGVAR(hardcode_direct, $1) + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$_LT_AC_TAGVAR(hardcode_minus_L, $1) + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1) + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$_LT_AC_TAGVAR(hardcode_automatic, $1) + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$_LT_AC_TAGVAR(link_all_deplibs, $1) + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$_LT_AC_TAGVAR(fix_srcfile_path, $1)" + +# Set to yes if exported symbols are required. +always_export_symbols=$_LT_AC_TAGVAR(always_export_symbols, $1) + +# The commands to list exported symbols. +export_symbols_cmds=$lt_[]_LT_AC_TAGVAR(export_symbols_cmds, $1) + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_[]_LT_AC_TAGVAR(exclude_expsyms, $1) + +# Symbols that must always be exported. +include_expsyms=$lt_[]_LT_AC_TAGVAR(include_expsyms, $1) + +ifelse([$1],[], +[# ### END LIBTOOL CONFIG], +[# ### END LIBTOOL TAG CONFIG: $tagname]) + +__EOF__ + +ifelse([$1],[], [ + case $host_os in + aix3*) + cat <<\EOF >> "$cfgfile" + +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +EOF + ;; + esac + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1) + + mv -f "$cfgfile" "$ofile" || \ + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" +]) +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi +])# AC_LIBTOOL_CONFIG + + +# AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME]) +# ------------------------------------------- +AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], +[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl + +_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + +if test "$GCC" = yes; then + _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' + + AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], + lt_cv_prog_compiler_rtti_exceptions, + [-fno-rtti -fno-exceptions], [], + [_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) +fi +])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI + + +# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE +# --------------------------------- +AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], +[AC_REQUIRE([AC_CANONICAL_HOST]) +AC_REQUIRE([AC_PROG_NM]) +AC_REQUIRE([AC_OBJEXT]) +# Check for command to grab the raw symbol name followed by C symbol from nm. +AC_MSG_CHECKING([command to parse $NM output from $compiler object]) +AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], +[ +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[[BCDEGRST]]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' + +# Transform the above into a raw symbol and a C symbol. +symxfrm='\1 \2\3 \3' + +# Transform an extracted symbol line into a proper C declaration +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[[BCDT]]' + ;; +cygwin* | mingw* | pw32*) + symcode='[[ABCDGISTW]]' + ;; +hpux*) # Its linker distinguishes data from code symbols + if test "$host_cpu" = ia64; then + symcode='[[ABCDEGRST]]' + fi + lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" + ;; +irix* | nonstopux*) + symcode='[[BCDEGRST]]' + ;; +osf*) + symcode='[[BCDEGQRST]]' + ;; +solaris* | sysv5*) + symcode='[[BDRT]]' + ;; +sysv4) + symcode='[[DFNSTU]]' + ;; +esac + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[[ABCDGIRSTW]]' ;; +esac + +# Try without a prefix undercore, then with it. +for ac_symprfx in "" "_"; do + + # Write the raw and C identifiers. + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext < $nlist) && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if grep ' nm_test_var$' "$nlist" >/dev/null; then + if grep ' nm_test_func$' "$nlist" >/dev/null; then + cat < conftest.$ac_ext +#ifdef __cplusplus +extern "C" { +#endif + +EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext' + + cat <> conftest.$ac_ext +#if defined (__STDC__) && __STDC__ +# define lt_ptr_t void * +#else +# define lt_ptr_t char * +# define const +#endif + +/* The mapping between symbol names and symbols. */ +const struct { + const char *name; + lt_ptr_t address; +} +lt_preloaded_symbols[[]] = +{ +EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext + cat <<\EOF >> conftest.$ac_ext + {0, (lt_ptr_t) 0} +}; + +#ifdef __cplusplus +} +#endif +EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_save_LIBS="$LIBS" + lt_save_CFLAGS="$CFLAGS" + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS="$lt_save_LIBS" + CFLAGS="$lt_save_CFLAGS" + else + echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD + fi + else + echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD + cat conftest.$ac_ext >&5 + fi + rm -f conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done +]) +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + AC_MSG_RESULT(failed) +else + AC_MSG_RESULT(ok) +fi +]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE + + +# AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME]) +# --------------------------------------- +AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC], +[_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)= +_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)= +_LT_AC_TAGVAR(lt_prog_compiler_static, $1)= + +AC_MSG_CHECKING([for $compiler option to produce PIC]) + ifelse([$1],[CXX],[ + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | os2* | pw32*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT' + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + sysv4*MP*) + if test -d /usr/nec; then + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + else + case $host_os in + aix4* | aix5*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68) + # Green Hills C++ Compiler + # _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + dgux*) + case $cc_basename in + ec++) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + ghcx) + # Green Hills C++ Compiler + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | kfreebsd*-gnu) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive" + if test "$host_cpu" != ia64; then + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + fi + ;; + aCC) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive" + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux*) + case $cc_basename in + KCC) + # KAI C++ Compiler + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + icpc) + # Intel C++ + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + cxx) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + *) + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd*) + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + ;; + RCC) + # Rational C++ 2.4.1 + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + cxx) + # Digital/Compaq C++ + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + sco*) + case $cc_basename in + CC) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + *) + ;; + esac + ;; + solaris*) + case $cc_basename in + CC) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + gcx) + # Green Hills C++ Compiler + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC) + # Sun C++ 4.x + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + lcc) + # Lucid + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC) + # NonStop-UX NCC 3.20 + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + *) + ;; + esac + ;; + unixware*) + ;; + vxworks*) + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +], +[ + if test "$GCC" = yes; then + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC (with -KPIC) is the default. + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + newsos6) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + ccc*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All Alpha code is PIC. + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All OSF/1 code is PIC. + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + sco3.2v5*) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kpic' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-dn' + ;; + + solaris*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sunos4*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + uts4*) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *) + _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +]) +AC_MSG_RESULT([$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)]) + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)"; then + AC_LIBTOOL_COMPILER_OPTION([if $compiler PIC flag $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) works], + _LT_AC_TAGVAR(lt_prog_compiler_pic_works, $1), + [$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])], [], + [case $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) in + "" | " "*) ;; + *) _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)" ;; + esac], + [_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + *) + _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])" + ;; +esac +]) + + +# AC_LIBTOOL_PROG_LD_SHLIBS([TAGNAME]) +# ------------------------------------ +# See if the linker supports building shared libraries. +AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS], +[AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) +ifelse([$1],[CXX],[ + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + case $host_os in + aix4* | aix5*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols' + else + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + _LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" + ;; + cygwin* | mingw*) + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols' + ;; + *) + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac +],[ + runpath_var= + _LT_AC_TAGVAR(allow_undefined_flag, $1)= + _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no + _LT_AC_TAGVAR(archive_cmds, $1)= + _LT_AC_TAGVAR(archive_expsym_cmds, $1)= + _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)= + _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)= + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)= + _LT_AC_TAGVAR(thread_safe_flag_spec, $1)= + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)= + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)= + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_minus_L, $1)=no + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_AC_TAGVAR(link_all_deplibs, $1)=unknown + _LT_AC_TAGVAR(hardcode_automatic, $1)=no + _LT_AC_TAGVAR(module_cmds, $1)= + _LT_AC_TAGVAR(module_expsym_cmds, $1)= + _LT_AC_TAGVAR(always_export_symbols, $1)=no + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + _LT_AC_TAGVAR(include_expsyms, $1)= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + _LT_AC_TAGVAR(exclude_expsyms, $1)="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + _LT_AC_TAGVAR(ld_shlibs, $1)=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + _LT_AC_TAGVAR(ld_shlibs, $1)=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_AC_TAGVAR(always_export_symbols, $1)=no + _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + _LT_AC_TAGVAR(ld_shlibs, $1)=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + sunos4*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_cmds, $1)="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ [01].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="$tmp_archive_cmds" + fi + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + + if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = yes; then + runpath_var=LD_RUN_PATH + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_AC_TAGVAR(always_export_symbols, $1)=yes + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols' + else + _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_AC_TAGVAR(archive_cmds, $1)='' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + + if test "$GCC" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + else + # We have old collect2 + _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + _LT_AC_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an empty executable. + _LT_AC_SYS_LIBPATH_AIX + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + _LT_AC_SYS_LIBPATH_AIX + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + _LT_AC_TAGVAR(always_export_symbols, $1)=yes + # Exported symbols can be pulled into shared objects from archives + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' ' + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds it's shared libraries. + _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + # see comment about different semantics on the GNU ld section + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + + bsdi4*) + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='true' + # FIXME: Should let the user specify the lib program. + _LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + case "$host_os" in + rhapsody* | darwin1.[[012]]) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[[012]]) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress' + ;; + 10.*) + _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + _LT_AC_TAGVAR(module_cmds, $1)='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_automatic, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience' + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + else + _LT_AC_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + dgux*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + freebsd1*) + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + hpux9*) + if test "$GCC" = yes; then + _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + ia64*) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_direct, $1)=no + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + ;; + *) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir' + fi + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + newsos6) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + openbsd*) + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + else + case $host_os in + openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + ;; + *) + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_AC_TAGVAR(archive_cmds, $1)='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + else + _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + fi + _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + sco3.2v5*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text' + if test "$GCC" = yes; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;; + esac + _LT_AC_TAGVAR(link_all_deplibs, $1)=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4) + case $host_vendor in + sni) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' + _LT_AC_TAGVAR(hardcode_direct, $1)=no + ;; + motorola) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4.3*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + _LT_AC_TAGVAR(ld_shlibs, $1)=yes + fi + ;; + + sysv4.2uw2*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_direct, $1)=yes + _LT_AC_TAGVAR(hardcode_minus_L, $1)=no + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*) + _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z ${wl}text' + if test "$GCC" = yes; then + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv5*) + _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + _LT_AC_TAGVAR(ld_shlibs, $1)=no + ;; + esac + fi +]) +AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)]) +test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)" in +x|xyes) + # Assume -lc should be added + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $_LT_AC_TAGVAR(archive_cmds, $1) in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + AC_MSG_CHECKING([whether -lc should be explicitly linked in]) + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if AC_TRY_EVAL(ac_compile) 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1) + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$_LT_AC_TAGVAR(allow_undefined_flag, $1) + _LT_AC_TAGVAR(allow_undefined_flag, $1)= + if AC_TRY_EVAL(_LT_AC_TAGVAR(archive_cmds, $1) 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) + then + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no + else + _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes + fi + _LT_AC_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + AC_MSG_RESULT([$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)]) + ;; + esac + fi + ;; +esac +])# AC_LIBTOOL_PROG_LD_SHLIBS + + +# _LT_AC_FILE_LTDLL_C +# ------------------- +# Be careful that the start marker always follows a newline. +AC_DEFUN([_LT_AC_FILE_LTDLL_C], [ +# /* ltdll.c starts here */ +# #define WIN32_LEAN_AND_MEAN +# #include +# #undef WIN32_LEAN_AND_MEAN +# #include +# +# #ifndef __CYGWIN__ +# # ifdef __CYGWIN32__ +# # define __CYGWIN__ __CYGWIN32__ +# # endif +# #endif +# +# #ifdef __cplusplus +# extern "C" { +# #endif +# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved); +# #ifdef __cplusplus +# } +# #endif +# +# #ifdef __CYGWIN__ +# #include +# DECLARE_CYGWIN_DLL( DllMain ); +# #endif +# HINSTANCE __hDllInstance_base; +# +# BOOL APIENTRY +# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved) +# { +# __hDllInstance_base = hInst; +# return TRUE; +# } +# /* ltdll.c ends here */ +])# _LT_AC_FILE_LTDLL_C + + +# _LT_AC_TAGVAR(VARNAME, [TAGNAME]) +# --------------------------------- +AC_DEFUN([_LT_AC_TAGVAR], [ifelse([$2], [], [$1], [$1_$2])]) + + +# old names +AC_DEFUN([AM_PROG_LIBTOOL], [AC_PROG_LIBTOOL]) +AC_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) +AC_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) +AC_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) +AC_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) +AC_DEFUN([AM_PROG_LD], [AC_PROG_LD]) +AC_DEFUN([AM_PROG_NM], [AC_PROG_NM]) + +# This is just to silence aclocal about the macro not being used +ifelse([AC_DISABLE_FAST_INSTALL]) + +AC_DEFUN([LT_AC_PROG_GCJ], +[AC_CHECK_TOOL(GCJ, gcj, no) + test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" + AC_SUBST(GCJFLAGS) +]) + +AC_DEFUN([LT_AC_PROG_RC], +[AC_CHECK_TOOL(RC, windres, no) +]) + +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_SED. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +# LT_AC_PROG_SED +# -------------- +# Check for a fully-functional sed program, that truncates +# as few characters as possible. Prefer GNU sed if found. +AC_DEFUN([LT_AC_PROG_SED], +[AC_MSG_CHECKING([for a sed that does not truncate output]) +AC_CACHE_VAL(lt_cv_path_SED, +[# Loop through the user's path and test for sed and gsed. +# Then use that list of sed's as ones to test for truncation. +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for lt_ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then + lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" + fi + done + done +done +lt_ac_max=0 +lt_ac_count=0 +# Add /usr/xpg4/bin/sed as it is typically found on Solaris +# along with /bin/sed that truncates output. +for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do + test ! -f $lt_ac_sed && break + cat /dev/null > conftest.in + lt_ac_count=0 + echo $ECHO_N "0123456789$ECHO_C" >conftest.in + # Check for GNU sed and select it if it is found. + if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then + lt_cv_path_SED=$lt_ac_sed + break + fi + while true; do + cat conftest.in conftest.in >conftest.tmp + mv conftest.tmp conftest.in + cp conftest.in conftest.nl + echo >>conftest.nl + $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break + cmp -s conftest.out conftest.nl || break + # 10000 chars as input seems more than enough + test $lt_ac_count -gt 10 && break + lt_ac_count=`expr $lt_ac_count + 1` + if test $lt_ac_count -gt $lt_ac_max; then + lt_ac_max=$lt_ac_count + lt_cv_path_SED=$lt_ac_sed + fi + done +done +SED=$lt_cv_path_SED +]) +AC_MSG_RESULT([$SED]) +]) + +# -*- Autoconf -*- +# Copyright (C) 2002, 2003 Free Software Foundation, Inc. +# Generated from amversion.in; do not edit by hand. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + +# AM_AUTOMAKE_VERSION(VERSION) +# ---------------------------- +# Automake X.Y traces this macro to ensure aclocal.m4 has been +# generated from the m4 files accompanying Automake X.Y. +AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.8"]) + +# AM_SET_CURRENT_AUTOMAKE_VERSION +# ------------------------------- +# Call AM_AUTOMAKE_VERSION so it can be traced. +# This function is AC_REQUIREd by AC_INIT_AUTOMAKE. +AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], + [AM_AUTOMAKE_VERSION([1.8.5])]) + +# AM_AUX_DIR_EXPAND + +# Copyright (C) 2001, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets +# $ac_aux_dir to `$srcdir/foo'. In other projects, it is set to +# `$srcdir', `$srcdir/..', or `$srcdir/../..'. +# +# Of course, Automake must honor this variable whenever it calls a +# tool from the auxiliary directory. The problem is that $srcdir (and +# therefore $ac_aux_dir as well) can be either absolute or relative, +# depending on how configure is run. This is pretty annoying, since +# it makes $ac_aux_dir quite unusable in subdirectories: in the top +# source directory, any form will work fine, but in subdirectories a +# relative path needs to be adjusted first. +# +# $ac_aux_dir/missing +# fails when called from a subdirectory if $ac_aux_dir is relative +# $top_srcdir/$ac_aux_dir/missing +# fails if $ac_aux_dir is absolute, +# fails when called from a subdirectory in a VPATH build with +# a relative $ac_aux_dir +# +# The reason of the latter failure is that $top_srcdir and $ac_aux_dir +# are both prefixed by $srcdir. In an in-source build this is usually +# harmless because $srcdir is `.', but things will broke when you +# start a VPATH build or use an absolute $srcdir. +# +# So we could use something similar to $top_srcdir/$ac_aux_dir/missing, +# iff we strip the leading $srcdir from $ac_aux_dir. That would be: +# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` +# and then we would define $MISSING as +# MISSING="\${SHELL} $am_aux_dir/missing" +# This will work as long as MISSING is not called from configure, because +# unfortunately $(top_srcdir) has no meaning in configure. +# However there are other variables, like CC, which are often used in +# configure, and could therefore not use this "fixed" $ac_aux_dir. +# +# Another solution, used here, is to always expand $ac_aux_dir to an +# absolute PATH. The drawback is that using absolute paths prevent a +# configured tree to be moved without reconfiguration. + +AC_DEFUN([AM_AUX_DIR_EXPAND], +[dnl Rely on autoconf to set up CDPATH properly. +AC_PREREQ([2.50])dnl +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` +]) + +# AM_CONDITIONAL -*- Autoconf -*- + +# Copyright (C) 1997, 2000, 2001, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 6 + +# AM_CONDITIONAL(NAME, SHELL-CONDITION) +# ------------------------------------- +# Define a conditional. +AC_DEFUN([AM_CONDITIONAL], +[AC_PREREQ(2.52)dnl + ifelse([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], + [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl +AC_SUBST([$1_TRUE]) +AC_SUBST([$1_FALSE]) +if $2; then + $1_TRUE= + $1_FALSE='#' +else + $1_TRUE='#' + $1_FALSE= +fi +AC_CONFIG_COMMANDS_PRE( +[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then + AC_MSG_ERROR([conditional "$1" was never defined. +Usually this means the macro was only invoked conditionally.]) +fi])]) + +# serial 7 -*- Autoconf -*- + +# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 +# Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + + +# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be +# written in clear, in which case automake, when reading aclocal.m4, +# will think it sees a *use*, and therefore will trigger all it's +# C support machinery. Also note that it means that autoscan, seeing +# CC etc. in the Makefile, will ask for an AC_PROG_CC use... + + + +# _AM_DEPENDENCIES(NAME) +# ---------------------- +# See how the compiler implements dependency checking. +# NAME is "CC", "CXX", "GCJ", or "OBJC". +# We try a few techniques and use that to set a single cache variable. +# +# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was +# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular +# dependency, and given that the user is not expected to run this macro, +# just rely on AC_PROG_CC. +AC_DEFUN([_AM_DEPENDENCIES], +[AC_REQUIRE([AM_SET_DEPDIR])dnl +AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl +AC_REQUIRE([AM_MAKE_INCLUDE])dnl +AC_REQUIRE([AM_DEP_TRACK])dnl + +ifelse([$1], CC, [depcc="$CC" am_compiler_list=], + [$1], CXX, [depcc="$CXX" am_compiler_list=], + [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'], + [$1], GCJ, [depcc="$GCJ" am_compiler_list='gcc3 gcc'], + [depcc="$$1" am_compiler_list=]) + +AC_CACHE_CHECK([dependency style of $depcc], + [am_cv_$1_dependencies_compiler_type], +[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named `D' -- because `-MD' means `put the output + # in D'. + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_$1_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` + fi + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with + # Solaris 8's {/usr,}/bin/sh. + touch sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + case $depmode in + nosideeffect) + # after this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + none) break ;; + esac + # We check with `-c' and `-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle `-M -o', and we need to detect this. + if depmode=$depmode \ + source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_$1_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_$1_dependencies_compiler_type=none +fi +]) +AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) +AM_CONDITIONAL([am__fastdep$1], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) +]) + + +# AM_SET_DEPDIR +# ------------- +# Choose a directory name for dependency files. +# This macro is AC_REQUIREd in _AM_DEPENDENCIES +AC_DEFUN([AM_SET_DEPDIR], +[AC_REQUIRE([AM_SET_LEADING_DOT])dnl +AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl +]) + + +# AM_DEP_TRACK +# ------------ +AC_DEFUN([AM_DEP_TRACK], +[AC_ARG_ENABLE(dependency-tracking, +[ --disable-dependency-tracking speeds up one-time build + --enable-dependency-tracking do not reject slow dependency extractors]) +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' +fi +AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) +AC_SUBST([AMDEPBACKSLASH]) +]) + +# Generate code to set up dependency tracking. -*- Autoconf -*- + +# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +#serial 2 + +# _AM_OUTPUT_DEPENDENCY_COMMANDS +# ------------------------------ +AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], +[for mf in $CONFIG_FILES; do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named `Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # So let's grep whole file. + if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then + dirpart=`AS_DIRNAME("$mf")` + else + continue + fi + grep '^DEP_FILES *= *[[^ @%:@]]' < "$mf" > /dev/null || continue + # Extract the definition of DEP_FILES from the Makefile without + # running `make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + # When using ansi2knr, U may be empty or an underscore; expand it + U=`sed -n 's/^U = //p' < "$mf"` + test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR" + # We invoke sed twice because it is the simplest approach to + # changing $(DEPDIR) to its actual value in the expansion. + for file in `sed -n ' + /^DEP_FILES = .*\\\\$/ { + s/^DEP_FILES = // + :loop + s/\\\\$// + p + n + /\\\\$/ b loop + p + } + /^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`AS_DIRNAME(["$file"])` + AS_MKDIR_P([$dirpart/$fdir]) + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done +done +])# _AM_OUTPUT_DEPENDENCY_COMMANDS + + +# AM_OUTPUT_DEPENDENCY_COMMANDS +# ----------------------------- +# This macro should only be invoked once -- use via AC_REQUIRE. +# +# This code is only required when automatic dependency tracking +# is enabled. FIXME. This creates each `.P' file that we will +# need in order to bootstrap the dependency handling code. +AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], +[AC_CONFIG_COMMANDS([depfiles], + [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], + [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) +]) + +# Do all the work for Automake. -*- Autoconf -*- + +# This macro actually does too much some checks are only needed if +# your package does certain things. But this isn't really a big deal. + +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 +# Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 11 + +# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) +# AM_INIT_AUTOMAKE([OPTIONS]) +# ----------------------------------------------- +# The call with PACKAGE and VERSION arguments is the old style +# call (pre autoconf-2.50), which is being phased out. PACKAGE +# and VERSION should now be passed to AC_INIT and removed from +# the call to AM_INIT_AUTOMAKE. +# We support both call styles for the transition. After +# the next Automake release, Autoconf can make the AC_INIT +# arguments mandatory, and then we can depend on a new Autoconf +# release and drop the old call support. +AC_DEFUN([AM_INIT_AUTOMAKE], +[AC_PREREQ([2.58])dnl +dnl Autoconf wants to disallow AM_ names. We explicitly allow +dnl the ones we care about. +m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl +AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl +AC_REQUIRE([AC_PROG_INSTALL])dnl +# test to see if srcdir already configured +if test "`cd $srcdir && pwd`" != "`pwd`" && + test -f $srcdir/config.status; then + AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi +AC_SUBST([CYGPATH_W]) + +# Define the identity of the package. +dnl Distinguish between old-style and new-style calls. +m4_ifval([$2], +[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl + AC_SUBST([PACKAGE], [$1])dnl + AC_SUBST([VERSION], [$2])], +[_AM_SET_OPTIONS([$1])dnl + AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl + AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl + +_AM_IF_OPTION([no-define],, +[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package]) + AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl + +# Some tools Automake needs. +AC_REQUIRE([AM_SANITY_CHECK])dnl +AC_REQUIRE([AC_ARG_PROGRAM])dnl +AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version}) +AM_MISSING_PROG(AUTOCONF, autoconf) +AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version}) +AM_MISSING_PROG(AUTOHEADER, autoheader) +AM_MISSING_PROG(MAKEINFO, makeinfo) +AM_MISSING_PROG(AMTAR, tar) +AM_PROG_INSTALL_SH +AM_PROG_INSTALL_STRIP +AC_REQUIRE([AM_PROG_MKDIR_P])dnl +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([AC_PROG_MAKE_SET])dnl +AC_REQUIRE([AM_SET_LEADING_DOT])dnl + +_AM_IF_OPTION([no-dependencies],, +[AC_PROVIDE_IFELSE([AC_PROG_CC], + [_AM_DEPENDENCIES(CC)], + [define([AC_PROG_CC], + defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl +AC_PROVIDE_IFELSE([AC_PROG_CXX], + [_AM_DEPENDENCIES(CXX)], + [define([AC_PROG_CXX], + defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl +]) +]) + + +# When config.status generates a header, we must update the stamp-h file. +# This file resides in the same directory as the config header +# that is generated. The stamp files are numbered to have different names. + +# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the +# loop where config.status creates the headers, so we can generate +# our stamp files there. +AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], +[# Compute $1's index in $config_headers. +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $1 | $1:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $1" >`AS_DIRNAME([$1])`/stamp-h[]$_am_stamp_count]) + +# AM_PROG_INSTALL_SH +# ------------------ +# Define $install_sh. + +# Copyright (C) 2001, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +AC_DEFUN([AM_PROG_INSTALL_SH], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +install_sh=${install_sh-"$am_aux_dir/install-sh"} +AC_SUBST(install_sh)]) + +# -*- Autoconf -*- +# Copyright (C) 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 1 + +# Check whether the underlying file-system supports filenames +# with a leading dot. For instance MS-DOS doesn't. +AC_DEFUN([AM_SET_LEADING_DOT], +[rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null +AC_SUBST([am__leading_dot])]) + + +# Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 +# Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 4 + +# AM_PROG_LEX +# ----------- +# Autoconf leaves LEX=: if lex or flex can't be found. Change that to a +# "missing" invocation, for better error output. +AC_DEFUN([AM_PROG_LEX], +[AC_PREREQ(2.50)dnl +AC_REQUIRE([AM_MISSING_HAS_RUN])dnl +AC_REQUIRE([AC_PROG_LEX])dnl +if test "$LEX" = :; then + LEX=${am_missing_run}flex +fi]) + +# Check to see how 'make' treats includes. -*- Autoconf -*- + +# Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 2 + +# AM_MAKE_INCLUDE() +# ----------------- +# Check to see how make treats includes. +AC_DEFUN([AM_MAKE_INCLUDE], +[am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo done +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +AC_MSG_CHECKING([for style of include used by $am_make]) +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# We grep out `Entering directory' and `Leaving directory' +# messages which can occur if `w' ends up in MAKEFLAGS. +# In particular we don't look at `^make:' because GNU make might +# be invoked under some other name (usually "gmake"), in which +# case it prints its new name instead of `make'. +if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then + am__include=include + am__quote= + _am_result=GNU +fi +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then + am__include=.include + am__quote="\"" + _am_result=BSD + fi +fi +AC_SUBST([am__include]) +AC_SUBST([am__quote]) +AC_MSG_RESULT([$_am_result]) +rm -f confinc confmf +]) + +# -*- Autoconf -*- + + +# Copyright (C) 1997, 1999, 2000, 2001, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 3 + +# AM_MISSING_PROG(NAME, PROGRAM) +# ------------------------------ +AC_DEFUN([AM_MISSING_PROG], +[AC_REQUIRE([AM_MISSING_HAS_RUN]) +$1=${$1-"${am_missing_run}$2"} +AC_SUBST($1)]) + + +# AM_MISSING_HAS_RUN +# ------------------ +# Define MISSING if not defined so far and test if it supports --run. +# If it does, set am_missing_run to use it, otherwise, to nothing. +AC_DEFUN([AM_MISSING_HAS_RUN], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing" +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + AC_MSG_WARN([`missing' script is too old or missing]) +fi +]) + +# AM_PROG_MKDIR_P +# --------------- +# Check whether `mkdir -p' is supported, fallback to mkinstalldirs otherwise. + +# Copyright (C) 2003, 2004 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# Automake 1.8 used `mkdir -m 0755 -p --' to ensure that directories +# created by `make install' are always world readable, even if the +# installer happens to have an overly restrictive umask (e.g. 077). +# This was a mistake. There are at least two reasons why we must not +# use `-m 0755': +# - it causes special bits like SGID to be ignored, +# - it may be too restrictive (some setups expect 775 directories). +# +# Do not use -m 0755 and let people choose whatever they expect by +# setting umask. +# +# We cannot accept any implementation of `mkdir' that recognizes `-p'. +# Some implementations (such as Solaris 8's) are not thread-safe: if a +# parallel make tries to run `mkdir -p a/b' and `mkdir -p a/c' +# concurrently, both version can detect that a/ is missing, but only +# one can create it and the other will error out. Consequently we +# restrict ourselves to GNU make (using the --version option ensures +# this.) +AC_DEFUN([AM_PROG_MKDIR_P], +[if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then + # Keeping the `.' argument allows $(mkdir_p) to be used without + # argument. Indeed, we sometimes output rules like + # $(mkdir_p) $(somedir) + # where $(somedir) is conditionally defined. + # (`test -n '$(somedir)' && $(mkdir_p) $(somedir)' is a more + # expensive solution, as it forces Make to start a sub-shell.) + mkdir_p='mkdir -p -- .' +else + # On NextStep and OpenStep, the `mkdir' command does not + # recognize any option. It will interpret all options as + # directories to create, and then abort because `.' already + # exists. + for d in ./-p ./--version; + do + test -d $d && rmdir $d + done + # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists. + if test -f "$ac_aux_dir/mkinstalldirs"; then + mkdir_p='$(mkinstalldirs)' + else + mkdir_p='$(install_sh) -d' + fi +fi +AC_SUBST([mkdir_p])]) + +# Helper functions for option handling. -*- Autoconf -*- + +# Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 2 + +# _AM_MANGLE_OPTION(NAME) +# ----------------------- +AC_DEFUN([_AM_MANGLE_OPTION], +[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) + +# _AM_SET_OPTION(NAME) +# ------------------------------ +# Set option NAME. Presently that only means defining a flag for this option. +AC_DEFUN([_AM_SET_OPTION], +[m4_define(_AM_MANGLE_OPTION([$1]), 1)]) + +# _AM_SET_OPTIONS(OPTIONS) +# ---------------------------------- +# OPTIONS is a space-separated list of Automake options. +AC_DEFUN([_AM_SET_OPTIONS], +[AC_FOREACH([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) + +# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) +# ------------------------------------------- +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +AC_DEFUN([_AM_IF_OPTION], +[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) + +# +# Check to make sure that the build environment is sane. +# + +# Copyright (C) 1996, 1997, 2000, 2001, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# serial 3 + +# AM_SANITY_CHECK +# --------------- +AC_DEFUN([AM_SANITY_CHECK], +[AC_MSG_CHECKING([whether build environment is sane]) +# Just in case +sleep 1 +echo timestamp > conftest.file +# Do `set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null` + if test "$[*]" = "X"; then + # -L didn't work. + set X `ls -t $srcdir/configure conftest.file` + fi + rm -f conftest.file + if test "$[*]" != "X $srcdir/configure conftest.file" \ + && test "$[*]" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken +alias in your environment]) + fi + + test "$[2]" = conftest.file + ) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +AC_MSG_RESULT(yes)]) + +# AM_PROG_INSTALL_STRIP + +# Copyright (C) 2001, 2003 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# One issue with vendor `install' (even GNU) is that you can't +# specify the program used to strip binaries. This is especially +# annoying in cross-compiling environments, where the build's strip +# is unlikely to handle the host's binaries. +# Fortunately install-sh will honor a STRIPPROG variable, so we +# always use install-sh in `make install-strip', and initialize +# STRIPPROG with the value of the STRIP variable (set by the user). +AC_DEFUN([AM_PROG_INSTALL_STRIP], +[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +# Installed binaries are usually stripped using `strip' when the user +# run `make install-strip'. However `strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the `STRIP' environment variable to overrule this program. +dnl Don't test for $cross_compiling = yes, because it might be `maybe'. +if test "$cross_compiling" != no; then + AC_CHECK_TOOL([STRIP], [strip], :) +fi +INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s" +AC_SUBST([INSTALL_STRIP_PROGRAM])]) + +m4_include([m4/debug.m4]) diff --git a/sdk/buddy-2.4/autom4te.cache/output.0 b/sdk/buddy-2.4/autom4te.cache/output.0 new file mode 100644 index 0000000..4dd56d7 --- /dev/null +++ b/sdk/buddy-2.4/autom4te.cache/output.0 @@ -0,0 +1,19914 @@ +@%:@! /bin/sh +@%:@ Guess values for system-dependent variables and create Makefiles. +@%:@ Generated by GNU Autoconf 2.69 for buddy 2.4. +@%:@ +@%:@ +@%:@ Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +@%:@ +@%:@ +@%:@ This configure script is free software; the Free Software Foundation +@%:@ gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in @%:@( + *posix*) : + set -o posix ;; @%:@( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in @%:@( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in @%:@(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in @%:@ (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in @%:@( + *posix*) : + set -o posix ;; @%:@( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in @%:@( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in @%:@ (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, +$0: including any error possibly output before this +$0: message. Then install a modern shell, or manually run +$0: the script under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +@%:@ as_fn_unset VAR +@%:@ --------------- +@%:@ Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +@%:@ as_fn_set_status STATUS +@%:@ ----------------------- +@%:@ Set @S|@? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} @%:@ as_fn_set_status + +@%:@ as_fn_exit STATUS +@%:@ ----------------- +@%:@ Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} @%:@ as_fn_exit + +@%:@ as_fn_mkdir_p +@%:@ ------------- +@%:@ Create "@S|@as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} @%:@ as_fn_mkdir_p + +@%:@ as_fn_executable_p FILE +@%:@ ----------------------- +@%:@ Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} @%:@ as_fn_executable_p +@%:@ as_fn_append VAR VALUE +@%:@ ---------------------- +@%:@ Append the text in VALUE to the end of the definition contained in VAR. Take +@%:@ advantage of any shell optimizations that allow amortized linear growth over +@%:@ repeated appends, instead of the typical quadratic growth present in naive +@%:@ implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +@%:@ as_fn_arith ARG... +@%:@ ------------------ +@%:@ Perform arithmetic evaluation on the ARGs, and store the result in the +@%:@ global @S|@as_val. Take advantage of shells that can avoid forks. The arguments +@%:@ must be portable across @S|@(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +@%:@ as_fn_error STATUS ERROR [LINENO LOG_FD] +@%:@ ---------------------------------------- +@%:@ Output "`basename @S|@0`: error: ERROR" to stderr. If LINENO and LOG_FD are +@%:@ provided, also output the error to LOG_FD, referencing LINENO. Then exit the +@%:@ script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} @%:@ as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in @%:@((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + + +# Check that we are running under the correct shell. +SHELL=${CONFIG_SHELL-/bin/sh} + +case X$ECHO in +X*--fallback-echo) + # Remove one level of quotation (which was required for Make). + ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','` + ;; +esac + +echo=${ECHO-echo} +if test "X$1" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift +elif test "X$1" = X--fallback-echo; then + # Avoid inline document here, it may be left over + : +elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then + # Yippee, $echo works! + : +else + # Restart under the correct shell. + exec $SHELL "$0" --no-reexec ${1+"$@"} +fi + +if test "X$1" = X--fallback-echo; then + # used as fallback echo + shift + cat </dev/null && + echo_test_string="`eval $cmd`" && + (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null + then + break + fi + done +fi + +if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + : +else + # The Solaris, AIX, and Digital Unix default echo programs unquote + # backslashes. This makes it impossible to quote backslashes using + # echo "$something" | sed 's/\\/\\\\/g' + # + # So, first we look for a working echo in the user's PATH. + + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for dir in $PATH /usr/ucb; do + IFS="$lt_save_ifs" + if (test -f $dir/echo || test -f $dir/echo$ac_exeext) && + test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + echo="$dir/echo" + break + fi + done + IFS="$lt_save_ifs" + + if test "X$echo" = Xecho; then + # We didn't find a better echo, so look for alternatives. + if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + # This shell has a builtin print -r that does the trick. + echo='print -r' + elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) && + test "X$CONFIG_SHELL" != X/bin/ksh; then + # If we have ksh, try running configure again with it. + ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} + export ORIGINAL_CONFIG_SHELL + CONFIG_SHELL=/bin/ksh + export CONFIG_SHELL + exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"} + else + # Try using printf. + echo='printf %s\n' + if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + # Cool, printf works + : + elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` && + test "X$echo_testing_string" = 'X\t' && + echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL + export CONFIG_SHELL + SHELL="$CONFIG_SHELL" + export SHELL + echo="$CONFIG_SHELL $0 --fallback-echo" + elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` && + test "X$echo_testing_string" = 'X\t' && + echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + echo="$CONFIG_SHELL $0 --fallback-echo" + else + # maybe with a smaller string... + prev=: + + for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do + if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null + then + break + fi + prev="$cmd" + done + + if test "$prev" != 'sed 50q "$0"'; then + echo_test_string=`eval $prev` + export echo_test_string + exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"} + else + # Oops. We lost completely, so just stick with echo. + echo=echo + fi + fi + fi + fi +fi +fi + +# Copy echo and quote the copy suitably for passing to libtool from +# the Makefile, instead of quoting the original, which is used later. +ECHO=$echo +if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then + ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo" +fi + + + + +tagnames=${tagnames+${tagnames},}CXX + +tagnames=${tagnames+${tagnames},}F77 + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIB@&t@OBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='buddy' +PACKAGE_TARNAME='buddy' +PACKAGE_VERSION='2.4' +PACKAGE_STRING='buddy 2.4' +PACKAGE_BUGREPORT='' +PACKAGE_URL='' + +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='LTLIBOBJS +LIB@&t@OBJS +LIBTOOL +ac_ct_F77 +FFLAGS +F77 +CXXCPP +CPP +RANLIB +AR +ECHO +LN_S +EGREP +GREP +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +am__fastdepCXX_FALSE +am__fastdepCXX_TRUE +CXXDEPMODE +ac_ct_CXX +CXXFLAGS +CXX +am__fastdepCC_FALSE +am__fastdepCC_TRUE +CCDEPMODE +AMDEPBACKSLASH +AMDEP_FALSE +AMDEP_TRUE +am__quote +am__include +DEPDIR +OBJEXT +EXEEXT +ac_ct_CC +CPPFLAGS +LDFLAGS +CFLAGS +CC +am__leading_dot +SET_MAKE +AWK +mkdir_p +INSTALL_STRIP_PROGRAM +STRIP +install_sh +AMTAR +MAKEINFO +AUTOHEADER +AUTOMAKE +AUTOCONF +ACLOCAL +VERSION +PACKAGE +CYGPATH_W +INSTALL_DATA +INSTALL_SCRIPT +INSTALL_PROGRAM +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +runstatedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +enable_dependency_tracking +enable_shared +enable_static +enable_fast_install +with_gnu_ld +enable_libtool_lock +with_pic +with_tags +enable_swap_count +enable_cache_stats +' + ac_precious_vars='build_alias +host_alias +target_alias +CC +CFLAGS +LDFLAGS +LIBS +CPPFLAGS +CXX +CXXFLAGS +CCC +CPP +CXXCPP +F77 +FFLAGS' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +runstatedir='${localstatedir}/run' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -runstatedir | --runstatedir | --runstatedi | --runstated \ + | --runstate | --runstat | --runsta | --runst | --runs \ + | --run | --ru | --r) + ac_prev=runstatedir ;; + -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ + | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ + | --run=* | --ru=* | --r=*) + runstatedir=$ac_optarg ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir runstatedir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures buddy 2.4 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + @<:@@S|@ac_default_prefix@:>@ + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + @<:@PREFIX@:>@ + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root @<:@DATAROOTDIR/doc/buddy@:>@ + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +Program names: + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM run sed PROGRAM on installed program names + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of buddy 2.4:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --disable-dependency-tracking speeds up one-time build + --enable-dependency-tracking do not reject slow dependency extractors + --enable-shared@<:@=PKGS@:>@ build shared libraries @<:@default=yes@:>@ + --enable-static@<:@=PKGS@:>@ build static libraries @<:@default=yes@:>@ + --enable-fast-install@<:@=PKGS@:>@ + optimize for fast installation @<:@default=yes@:>@ + --disable-libtool-lock avoid locking (might break parallel builds) + --enable-swap-count Count number of fundamental variable swaps (for + debugging) + --enable-cache-stats Gather statistical information about operator and + unique node caching (for debugging) + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-gnu-ld assume the C compiler uses GNU ld @<:@default=no@:>@ + --with-pic try to use only PIC/non-PIC objects @<:@default=use + both@:>@ + --with-tags@<:@=TAGS@:>@ include additional configurations @<:@automatic@:>@ + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CXX C++ compiler command + CXXFLAGS C++ compiler flags + CPP C preprocessor + CXXCPP C++ preprocessor + F77 Fortran 77 compiler command + FFLAGS Fortran 77 compiler flags + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to the package provider. +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +buddy configure 2.4 +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +@%:@ ac_fn_c_try_compile LINENO +@%:@ -------------------------- +@%:@ Try to compile conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_c_try_compile + +@%:@ ac_fn_cxx_try_compile LINENO +@%:@ ---------------------------- +@%:@ Try to compile conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_cxx_try_compile + +@%:@ ac_fn_c_try_link LINENO +@%:@ ----------------------- +@%:@ Try to link conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_c_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_c_try_link + +@%:@ ac_fn_c_try_cpp LINENO +@%:@ ---------------------- +@%:@ Try to preprocess conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_c_try_cpp + +@%:@ ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES +@%:@ ------------------------------------------------------- +@%:@ Tests whether HEADER exists, giving a warning if it cannot be compiled using +@%:@ the include files in INCLUDES and setting the cache variable VAR +@%:@ accordingly. +ac_fn_c_check_header_mongrel () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if eval \${$3+:} false; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +else + # Is the header compilable? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 +$as_echo_n "checking $2 usability... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +@%:@include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_header_compiler=yes +else + ac_header_compiler=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 +$as_echo "$ac_header_compiler" >&6; } + +# Is the header present? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 +$as_echo_n "checking $2 presence... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@include <$2> +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + ac_header_preproc=yes +else + ac_header_preproc=no +fi +rm -f conftest.err conftest.i conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 +$as_echo "$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( + yes:no: ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 +$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; + no:yes:* ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 +$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 +$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 +$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 +$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=\$ac_header_compiler" +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} @%:@ ac_fn_c_check_header_mongrel + +@%:@ ac_fn_c_try_run LINENO +@%:@ ---------------------- +@%:@ Try to link conftest.@S|@ac_ext, and return whether this succeeded. Assumes +@%:@ that executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_c_try_run + +@%:@ ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES +@%:@ ------------------------------------------------------- +@%:@ Tests whether HEADER exists and can be compiled using the include files in +@%:@ INCLUDES, setting the cache variable VAR accordingly. +ac_fn_c_check_header_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +@%:@include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} @%:@ ac_fn_c_check_header_compile + +@%:@ ac_fn_c_check_func LINENO FUNC VAR +@%:@ ---------------------------------- +@%:@ Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} @%:@ ac_fn_c_check_func + +@%:@ ac_fn_cxx_try_cpp LINENO +@%:@ ------------------------ +@%:@ Try to preprocess conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_cxx_try_cpp + +@%:@ ac_fn_cxx_try_link LINENO +@%:@ ------------------------- +@%:@ Try to link conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_cxx_try_link + +@%:@ ac_fn_cxx_check_func LINENO FUNC VAR +@%:@ ------------------------------------ +@%:@ Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_cxx_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} @%:@ ac_fn_cxx_check_func + +@%:@ ac_fn_f77_try_compile LINENO +@%:@ ---------------------------- +@%:@ Try to compile conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_f77_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_f77_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_f77_try_compile + +@%:@ ac_fn_f77_try_link LINENO +@%:@ ------------------------- +@%:@ Try to link conftest.@S|@ac_ext, and return whether this succeeded. +ac_fn_f77_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_f77_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} @%:@ ac_fn_f77_try_link +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by buddy $as_me 2.4, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +@%:@define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +@%:@define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +@%:@define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +@%:@define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +@%:@define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +@%:@define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in @%:@(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_aux_dir= +for ac_dir in tools "$srcdir"/tools; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in tools \"$srcdir\"/tools" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + +am__api_version="1.8" +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +# Reject install programs that cannot install multiple files. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +$as_echo_n "checking for a BSD-compatible install... " >&6; } +if test -z "$INSTALL"; then +if ${ac_cv_path_install+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + # Account for people who put trailing slashes in PATH elements. +case $as_dir/ in @%:@(( + ./ | .// | /[cC]/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ + /usr/ucb/* ) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + rm -rf conftest.one conftest.two conftest.dir + echo one > conftest.one + echo two > conftest.two + mkdir conftest.dir + if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && + test -s conftest.one && test -s conftest.two && + test -s conftest.dir/conftest.one && + test -s conftest.dir/conftest.two + then + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + fi + done + done + ;; +esac + + done +IFS=$as_save_IFS + +rm -rf conftest.one conftest.two conftest.dir + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. Don't cache a + # value for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + INSTALL=$ac_install_sh + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +$as_echo "$INSTALL" >&6; } + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 +$as_echo_n "checking whether build environment is sane... " >&6; } +# Just in case +sleep 1 +echo timestamp > conftest.file +# Do `set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null` + if test "$*" = "X"; then + # -L didn't work. + set X `ls -t $srcdir/configure conftest.file` + fi + rm -f conftest.file + if test "$*" != "X $srcdir/configure conftest.file" \ + && test "$*" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + as_fn_error $? "ls -t appears to fail. Make sure there is not a broken +alias in your environment" "$LINENO" 5 + fi + + test "$2" = conftest.file + ) +then + # Ok. + : +else + as_fn_error $? "newly created file is older than distributed files! +Check your system clock" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +test "$program_prefix" != NONE && + program_transform_name="s&^&$program_prefix&;$program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s&\$&$program_suffix&;$program_transform_name" +# Double any \ or $. +# By default was `s,x,x', remove it if useless. +ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' +program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` + +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` + +test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing" +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5 +$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;} +fi + +if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then + # Keeping the `.' argument allows $(mkdir_p) to be used without + # argument. Indeed, we sometimes output rules like + # $(mkdir_p) $(somedir) + # where $(somedir) is conditionally defined. + # (`test -n '$(somedir)' && $(mkdir_p) $(somedir)' is a more + # expensive solution, as it forces Make to start a sub-shell.) + mkdir_p='mkdir -p -- .' +else + # On NextStep and OpenStep, the `mkdir' command does not + # recognize any option. It will interpret all options as + # directories to create, and then abort because `.' already + # exists. + for d in ./-p ./--version; + do + test -d $d && rmdir $d + done + # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists. + if test -f "$ac_aux_dir/mkinstalldirs"; then + mkdir_p='$(mkinstalldirs)' + else + mkdir_p='$(install_sh) -d' + fi +fi + +for ac_prog in gawk mawk nawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AWK+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AWK="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } +set x ${MAKE-make} +ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat >conftest.make <<\_ACEOF +SHELL = /bin/sh +all: + @echo '@@@%%%=$(MAKE)=@@@%%%' +_ACEOF +# GNU make sometimes prints "make[1]: Entering ...", which would confuse us. +case `${MAKE-make} -f conftest.make 2>/dev/null` in + *@@@%%%=?*=@@@%%%*) + eval ac_cv_prog_make_${ac_make}_set=yes;; + *) + eval ac_cv_prog_make_${ac_make}_set=no;; +esac +rm -f conftest.make +fi +if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + SET_MAKE= +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + SET_MAKE="MAKE=${MAKE-make}" +fi + +rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null + +# test to see if srcdir already configured +if test "`cd $srcdir && pwd`" != "`pwd`" && + test -f $srcdir/config.status; then + as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi + + +# Define the identity of the package. + PACKAGE='buddy' + VERSION='2.4' + + +# Some tools Automake needs. + +ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} + + +AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} + + +AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} + + +AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} + + +MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} + + +AMTAR=${AMTAR-"${am_missing_run}tar"} + +install_sh=${install_sh-"$am_aux_dir/install-sh"} + +# Installed binaries are usually stripped using `strip' when the user +# run `make install-strip'. However `strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the `STRIP' environment variable to overrule this program. +if test "$cross_compiling" != no; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +fi +INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s" + +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. + + + + +MAJOR_VERSION=`echo "$VERSION" | sed -e 's/^\([0-9]*\)\.[0-9]*.*$/\1/'` +MINOR_VERSION=`echo "$VERSION" | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'` + +cat >>confdefs.h <<_ACEOF +@%:@define MAJOR_VERSION $MAJOR_VERSION +_ACEOF + + +cat >>confdefs.h <<_ACEOF +@%:@define MINOR_VERSION $MINOR_VERSION +_ACEOF + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $@%:@ != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl.exe + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl.exe +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See \`config.log' for more details" "$LINENO" 5; } + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +$as_echo_n "checking whether the C compiler works... " >&6; } +ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "C compiler cannot create executables +See \`config.log' for more details" "$LINENO" 5; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +$as_echo_n "checking for C compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$ac_file" >&6; } +ac_exeext=$ac_cv_exeext + +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +ac_clean_files="$ac_clean_files conftest.out" +# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if ${ac_cv_objext+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of object files: cannot compile +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if ${ac_cv_c_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if ${ac_cv_prog_cc_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +DEPDIR="${am__leading_dot}deps" + +ac_config_commands="$ac_config_commands depfiles" + + +am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo done +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 +$as_echo_n "checking for style of include used by $am_make... " >&6; } +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# We grep out `Entering directory' and `Leaving directory' +# messages which can occur if `w' ends up in MAKEFLAGS. +# In particular we don't look at `^make:' because GNU make might +# be invoked under some other name (usually "gmake"), in which +# case it prints its new name instead of `make'. +if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then + am__include=include + am__quote= + _am_result=GNU +fi +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then + am__include=.include + am__quote="\"" + _am_result=BSD + fi +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 +$as_echo "$_am_result" >&6; } +rm -f confinc confmf + +@%:@ Check whether --enable-dependency-tracking was given. +if test "${enable_dependency_tracking+set}" = set; then : + enableval=$enable_dependency_tracking; +fi + +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' +fi + + +if test "x$enable_dependency_tracking" != xno; then + AMDEP_TRUE= + AMDEP_FALSE='#' +else + AMDEP_TRUE='#' + AMDEP_FALSE= +fi + + + + +depcc="$CC" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CC_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named `D' -- because `-MD' means `put the output + # in D'. + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CC_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with + # Solaris 8's {/usr,}/bin/sh. + touch sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + case $depmode in + nosideeffect) + # after this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + none) break ;; + esac + # We check with `-c' and `-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle `-M -o', and we need to detect this. + if depmode=$depmode \ + source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CC_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CC_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } +CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type + + + +if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then + am__fastdepCC_TRUE= + am__fastdepCC_FALSE='#' +else + am__fastdepCC_TRUE='#' + am__fastdepCC_FALSE= +fi + + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CXX="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if ${ac_cv_cxx_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if ${ac_cv_prog_cxx_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CXX" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CXX_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named `D' -- because `-MD' means `put the output + # in D'. + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CXX_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with + # Solaris 8's {/usr,}/bin/sh. + touch sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + case $depmode in + nosideeffect) + # after this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + none) break ;; + esac + # We check with `-c' and `-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle `-M -o', and we need to detect this. + if depmode=$depmode \ + source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CXX_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CXX_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } +CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type + + + +if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then + am__fastdepCXX_TRUE= + am__fastdepCXX_FALSE='#' +else + am__fastdepCXX_TRUE='#' + am__fastdepCXX_FALSE= +fi + + + +@%:@ Check whether --enable-shared was given. +if test "${enable_shared+set}" = set; then : + enableval=$enable_shared; p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_shared=yes +fi + + +@%:@ Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_static=yes +fi + + +@%:@ Check whether --enable-fast-install was given. +if test "${enable_fast_install+set}" = set; then : + enableval=$enable_fast_install; p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_fast_install=yes +fi + + +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if ${ac_cv_build+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if ${ac_cv_host+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +$as_echo_n "checking for a sed that does not truncate output... " >&6; } +if ${lt_cv_path_SED+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Loop through the user's path and test for sed and gsed. +# Then use that list of sed's as ones to test for truncation. +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for lt_ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then + lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" + fi + done + done +done +lt_ac_max=0 +lt_ac_count=0 +# Add /usr/xpg4/bin/sed as it is typically found on Solaris +# along with /bin/sed that truncates output. +for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do + test ! -f $lt_ac_sed && break + cat /dev/null > conftest.in + lt_ac_count=0 + echo $ECHO_N "0123456789$ECHO_C" >conftest.in + # Check for GNU sed and select it if it is found. + if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then + lt_cv_path_SED=$lt_ac_sed + break + fi + while true; do + cat conftest.in conftest.in >conftest.tmp + mv conftest.tmp conftest.in + cp conftest.in conftest.nl + echo >>conftest.nl + $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break + cmp -s conftest.out conftest.nl || break + # 10000 chars as input seems more than enough + test $lt_ac_count -gt 10 && break + lt_ac_count=`expr $lt_ac_count + 1` + if test $lt_ac_count -gt $lt_ac_max; then + lt_ac_max=$lt_ac_count + lt_cv_path_SED=$lt_ac_sed + fi + done +done +SED=$lt_cv_path_SED + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 +$as_echo "$SED" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if ${ac_cv_path_GREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if ${ac_cv_path_EGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'EGREP' >> "conftest.nl" + "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + + +@%:@ Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'` + while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do + ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some GNU ld's only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU ld's only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +$as_echo_n "checking for $LD option to reload object files... " >&6; } +if ${lt_cv_ld_reload_flag+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_reload_flag='-r' +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +$as_echo "$lt_cv_ld_reload_flag" >&6; } +reload_flag=$lt_cv_ld_reload_flag +case $reload_flag in +"" | " "*) ;; +*) reload_flag=" $reload_flag" ;; +esac +reload_cmds='$LD$reload_flag -o $output$reload_objs' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD-compatible nm" >&5 +$as_echo_n "checking for BSD-compatible nm... " >&6; } +if ${lt_cv_path_NM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/${ac_tool_prefix}nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + esac + fi + done + IFS="$lt_save_ifs" + test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +$as_echo "$lt_cv_path_NM" >&6; } +NM="$lt_cv_path_NM" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +$as_echo_n "checking whether ln -s works... " >&6; } +LN_S=$as_ln_s +if test "$LN_S" = "ln -s"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +$as_echo "no, using $LN_S" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognise dependent libraries" >&5 +$as_echo_n "checking how to recognise dependent libraries... " >&6; } +if ${lt_cv_deplibs_check_method+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_deplibs_check_method='unknown' +# Need to set the preceding variable on all platforms that support +# interlibrary dependencies. +# 'none' -- dependencies not supported. +# `unknown' -- same as none, but documents that we really don't know. +# 'pass_all' -- all dependencies passed with no checks. +# 'test_compile' -- check by making test program. +# 'file_magic [[regex]]' -- check by looking for files in library path +# which responds to the $file_magic_cmd with a given extended regex. +# If you have `file' or equivalent on your system and you're not sure +# whether `pass_all' will *always* work, you probably want this one. + +case $host_os in +aix4* | aix5*) + lt_cv_deplibs_check_method=pass_all + ;; + +beos*) + lt_cv_deplibs_check_method=pass_all + ;; + +bsdi4*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' + lt_cv_file_magic_cmd='/usr/bin/file -L' + lt_cv_file_magic_test_file=/shlib/libc.so + ;; + +cygwin*) + # func_win32_libid is a shell function defined in ltmain.sh + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + ;; + +mingw* | pw32*) + # Base MSYS/MinGW do not provide the 'file' command needed by + # func_win32_libid shell function, so use a weaker test based on 'objdump'. + lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | kfreebsd*-gnu) + if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case "$host_cpu" in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]' + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be Linux ELF. +linux*) + case $host_cpu in + alpha*|hppa*|i*86|ia64*|m68*|mips*|powerpc*|sparc*|s390*|sh*|x86_64*) + lt_cv_deplibs_check_method=pass_all ;; + *) + # glibc up to 2.1.1 does not perform some relocations on ARM + # this will be overridden with pass_all, but let us keep it just in case + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;; + esac + lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so` + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +nto-qnx*) + lt_cv_deplibs_check_method=unknown + ;; + +openbsd*) + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object' + else + lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +sco3.2v5*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +$as_echo "$lt_cv_deplibs_check_method" >&6; } +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +@%:@ Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '#line __oline__ "configure"' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + lt_cv_cc_lib64_suffix=no + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case "`/usr/bin/file conftest.$ac_objext`" in + *32-bit*) + case $host in + x86_64-*linux*) + LD="${LD-ld} -m elf_i386" + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + lt_cv_cc_lib64_suffix=yes + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + lt_cv_cc_lib64_suffix=yes + ;; + s390*-*linux*) + LD="${LD-ld} -m elf64_s390" + lt_cv_cc_lib64_suffix=yes + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + lt_cv_cc_lib64_suffix=yes + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 +$as_echo_n "checking whether the C compiler needs -belf... " >&6; } +if ${lt_cv_cc_needs_belf+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_cc_needs_belf=yes +else + lt_cv_cc_needs_belf=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +$as_echo "$lt_cv_cc_needs_belf" >&6; } + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; + +esac + +need_locks="$enable_libtool_lock" + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@ifdef __STDC__ +@%:@ include +@%:@else +@%:@ include +@%:@endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@ifdef __STDC__ +@%:@ include +@%:@else +@%:@ include +@%:@endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "@%:@define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +@%:@define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in dlfcn.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default" +if test "x$ac_cv_header_dlfcn_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +@%:@define HAVE_DLFCN_H 1 +_ACEOF + +fi + +done + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +$as_echo_n "checking how to run the C++ preprocessor... " >&6; } +if test -z "$CXXCPP"; then + if ${ac_cv_prog_CXXCPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@ifdef __STDC__ +@%:@ include +@%:@else +@%:@ include +@%:@endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CXXCPP=$CXXCPP + +fi + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +$as_echo "$CXXCPP" >&6; } +ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@ifdef __STDC__ +@%:@ include +@%:@else +@%:@ include +@%:@endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +@%:@include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +ac_ext=f +ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5' +ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_f77_compiler_gnu +if test -n "$ac_tool_prefix"; then + for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$F77"; then + ac_cv_prog_F77="$F77" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_F77="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +F77=$ac_cv_prog_F77 +if test -n "$F77"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $F77" >&5 +$as_echo "$F77" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$F77" && break + done +fi +if test -z "$F77"; then + ac_ct_F77=$F77 + for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_F77"; then + ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_F77="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_F77=$ac_cv_prog_ac_ct_F77 +if test -n "$ac_ct_F77"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_F77" >&5 +$as_echo "$ac_ct_F77" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_F77" && break +done + + if test "x$ac_ct_F77" = x; then + F77="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + F77=$ac_ct_F77 + fi +fi + + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran 77 compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done +rm -f a.out + +# If we don't use `.F' as extension, the preprocessor is not run on the +# input file. (Note that this only needs to work for GNU compilers.) +ac_save_ext=$ac_ext +ac_ext=F +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran 77 compiler" >&5 +$as_echo_n "checking whether we are using the GNU Fortran 77 compiler... " >&6; } +if ${ac_cv_f77_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat > conftest.$ac_ext <<_ACEOF + program main +#ifndef __GNUC__ + choke me +#endif + + end +_ACEOF +if ac_fn_f77_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_f77_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_f77_compiler_gnu" >&5 +$as_echo "$ac_cv_f77_compiler_gnu" >&6; } +ac_ext=$ac_save_ext +ac_test_FFLAGS=${FFLAGS+set} +ac_save_FFLAGS=$FFLAGS +FFLAGS= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $F77 accepts -g" >&5 +$as_echo_n "checking whether $F77 accepts -g... " >&6; } +if ${ac_cv_prog_f77_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + FFLAGS=-g +cat > conftest.$ac_ext <<_ACEOF + program main + + end +_ACEOF +if ac_fn_f77_try_compile "$LINENO"; then : + ac_cv_prog_f77_g=yes +else + ac_cv_prog_f77_g=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_f77_g" >&5 +$as_echo "$ac_cv_prog_f77_g" >&6; } +if test "$ac_test_FFLAGS" = set; then + FFLAGS=$ac_save_FFLAGS +elif test $ac_cv_prog_f77_g = yes; then + if test "x$ac_cv_f77_compiler_gnu" = xyes; then + FFLAGS="-g -O2" + else + FFLAGS="-g" + fi +else + if test "x$ac_cv_f77_compiler_gnu" = xyes; then + FFLAGS="-O2" + else + FFLAGS= + fi +fi + +if test $ac_compiler_gnu = yes; then + G77=yes +else + G77= +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + +# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers! + +# find the maximum length of command line arguments +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +$as_echo_n "checking the maximum length of command line arguments... " >&6; } +if ${lt_cv_sys_max_cmd_len+:} false; then : + $as_echo_n "(cached) " >&6 +else + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + *) + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while (test "X"`$CONFIG_SHELL $0 --fallback-echo "X$teststring" 2>/dev/null` \ + = "XX$teststring") >/dev/null 2>&1 && + new_result=`expr "X$teststring" : ".*" 2>&1` && + lt_cv_sys_max_cmd_len=$new_result && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + teststring= + # Add a significant safety factor because C++ compilers can tack on massive + # amounts of additional arguments before passing them to the linker. + # It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + ;; + esac + +fi + +if test -n $lt_cv_sys_max_cmd_len ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +$as_echo "$lt_cv_sys_max_cmd_len" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 +$as_echo "none" >&6; } +fi + + + + +# Check for command to grab the raw symbol name followed by C symbol from nm. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; } +if ${lt_cv_sys_global_symbol_pipe+:} false; then : + $as_echo_n "(cached) " >&6 +else + +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[BCDEGRST]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([_A-Za-z][_A-Za-z0-9]*\)' + +# Transform the above into a raw symbol and a C symbol. +symxfrm='\1 \2\3 \3' + +# Transform an extracted symbol line into a proper C declaration +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[BCDT]' + ;; +cygwin* | mingw* | pw32*) + symcode='[ABCDGISTW]' + ;; +hpux*) # Its linker distinguishes data from code symbols + if test "$host_cpu" = ia64; then + symcode='[ABCDEGRST]' + fi + lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" + ;; +irix* | nonstopux*) + symcode='[BCDEGRST]' + ;; +osf*) + symcode='[BCDEGQRST]' + ;; +solaris* | sysv5*) + symcode='[BDRT]' + ;; +sysv4) + symcode='[DFNSTU]' + ;; +esac + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[ABCDGIRSTW]' ;; +esac + +# Try without a prefix undercore, then with it. +for ac_symprfx in "" "_"; do + + # Write the raw and C identifiers. + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Now try to grab the symbols. + nlist=conftest.nm + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\""; } >&5 + (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if grep ' nm_test_var$' "$nlist" >/dev/null; then + if grep ' nm_test_func$' "$nlist" >/dev/null; then + cat < conftest.$ac_ext +#ifdef __cplusplus +extern "C" { +#endif + +EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext' + + cat <> conftest.$ac_ext +#if defined (__STDC__) && __STDC__ +# define lt_ptr_t void * +#else +# define lt_ptr_t char * +# define const +#endif + +/* The mapping between symbol names and symbols. */ +const struct { + const char *name; + lt_ptr_t address; +} +lt_preloaded_symbols[] = +{ +EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext + cat <<\EOF >> conftest.$ac_ext + {0, (lt_ptr_t) 0} +}; + +#ifdef __cplusplus +} +#endif +EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_save_LIBS="$LIBS" + lt_save_CFLAGS="$CFLAGS" + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS="$lt_save_LIBS" + CFLAGS="$lt_save_CFLAGS" + else + echo "cannot find nm_test_func in $nlist" >&5 + fi + else + echo "cannot find nm_test_var in $nlist" >&5 + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 + fi + else + echo "$progname: failed program was:" >&5 + cat conftest.$ac_ext >&5 + fi + rm -f conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done + +fi + +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +$as_echo "failed" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +$as_echo_n "checking for objdir... " >&6; } +if ${lt_cv_objdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +$as_echo "$lt_cv_objdir" >&6; } +objdir=$lt_cv_objdir + + + + + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed='sed -e s/^X//' +sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' + +# Constants: +rm="rm -f" + +# Global variables: +default_ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except M$VC, +# which needs '.lib'). +libext=a +ltmain="$ac_aux_dir/ltmain.sh" +ofile="$default_ofile" +with_gnu_ld="$lt_cv_prog_gnu_ld" + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. +set dummy ${ac_tool_prefix}ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="${ac_tool_prefix}ar" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_AR"; then + ac_ct_AR=$AR + # Extract the first word of "ar", so it can be a program name with args. +set dummy ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="ar" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +else + AR="$ac_cv_prog_AR" +fi + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RANLIB=$ac_cv_prog_RANLIB +if test -n "$RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +$as_echo "$RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_RANLIB"; then + ac_ct_RANLIB=$RANLIB + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_RANLIB"; then + ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_RANLIB="ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB +if test -n "$ac_ct_RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +$as_echo "$ac_ct_RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_RANLIB" = x; then + RANLIB=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + RANLIB=$ac_ct_RANLIB + fi +else + RANLIB="$ac_cv_prog_RANLIB" +fi + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$AR" && AR=ar +test -z "$AR_FLAGS" && AR_FLAGS=cru +test -z "$AS" && AS=as +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$DLLTOOL" && DLLTOOL=dlltool +test -z "$LD" && LD=ld +test -z "$LN_S" && LN_S="ln -s" +test -z "$MAGIC_CMD" && MAGIC_CMD=file +test -z "$NM" && NM=nm +test -z "$SED" && SED=sed +test -z "$OBJDUMP" && OBJDUMP=objdump +test -z "$RANLIB" && RANLIB=: +test -z "$STRIP" && STRIP=: +test -z "$ac_objext" && ac_objext=o + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds" + ;; + *) + old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib" +fi + +# Only perform the check for file, if the check method requires it +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 +$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/${ac_tool_prefix}file; then + lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5 +$as_echo_n "checking for file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/file; then + lt_cv_path_MAGIC_CMD="$ac_dir/file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + else + MAGIC_CMD=: + fi +fi + + fi + ;; +esac + +enable_dlopen=no +enable_win32_dll=no + +@%:@ Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + + +@%:@ Check whether --with-pic was given. +if test "${with_pic+set}" = set; then : + withval=$with_pic; pic_mode="$withval" +else + pic_mode=default +fi + +test -z "$pic_mode" && pic_mode=default + +# Use C for the default configuration in the libtool script +tagname= +lt_save_CC="$CC" +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +objext=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}\n' + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# +# Check for any special shared library compilation flags. +# +lt_prog_cc_shlib= +if test "$GCC" = no; then + case $host_os in + sco3.2v5*) + lt_prog_cc_shlib='-belf' + ;; + esac +fi +if test -n "$lt_prog_cc_shlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' requires \`$lt_prog_cc_shlib' to build shared libraries" >&5 +$as_echo "$as_me: WARNING: \`$CC' requires \`$lt_prog_cc_shlib' to build shared libraries" >&2;} + if echo "$old_CC $old_CFLAGS " | grep "[ ]$lt_prog_cc_shlib[ ]" >/dev/null; then : + else + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: add \`$lt_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&5 +$as_echo "$as_me: WARNING: add \`$lt_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&2;} + lt_cv_prog_cc_can_build_shared=no + fi +fi + + +# +# Check to make sure the static flag actually works. +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_prog_compiler_static works" >&5 +$as_echo_n "checking if $compiler static flag $lt_prog_compiler_static works... " >&6; } +if ${lt_prog_compiler_static_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_static_works=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_prog_compiler_static" + printf "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + else + lt_prog_compiler_static_works=yes + fi + fi + $rm conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_static_works" >&5 +$as_echo "$lt_prog_compiler_static_works" >&6; } + +if test x"$lt_prog_compiler_static_works" = xyes; then + : +else + lt_prog_compiler_static= +fi + + + + +lt_prog_compiler_no_builtin_flag= + +if test "$GCC" = yes; then + lt_prog_compiler_no_builtin_flag=' -fno-builtin' + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" +else + : +fi + +fi + +lt_prog_compiler_wl= +lt_prog_compiler_pic= +lt_prog_compiler_static= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + if test "$GCC" = yes; then + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_static='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + ;; + + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + else + lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static='-non_shared' + ;; + + newsos6) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-static' + ;; + ccc*) + lt_prog_compiler_wl='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + + sco3.2v5*) + lt_prog_compiler_pic='-Kpic' + lt_prog_compiler_static='-dn' + ;; + + solaris*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sunos4*) + lt_prog_compiler_wl='-Qoption ld ' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic='-Kconform_pic' + lt_prog_compiler_static='-Bstatic' + fi + ;; + + uts4*) + lt_prog_compiler_pic='-pic' + lt_prog_compiler_static='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic" >&5 +$as_echo "$lt_prog_compiler_pic" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } +if ${lt_prog_compiler_pic_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works" >&5 +$as_echo "$lt_prog_compiler_pic_works" >&6; } + +if test x"$lt_prog_compiler_pic_works" = xyes; then + case $lt_prog_compiler_pic in + "" | " "*) ;; + *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; + esac +else + lt_prog_compiler_pic= + lt_prog_compiler_can_build_shared=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic= + ;; + *) + lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag= + enable_shared_with_static_runtimes=no + archive_cmds= + archive_expsym_cmds= + old_archive_From_new_cmds= + old_archive_from_expsyms_cmds= + export_dynamic_flag_spec= + whole_archive_flag_spec= + thread_safe_flag_spec= + hardcode_libdir_flag_spec= + hardcode_libdir_flag_spec_ld= + hardcode_libdir_separator= + hardcode_direct=no + hardcode_minus_L=no + hardcode_shlibpath_var=unsupported + link_all_deplibs=unknown + hardcode_automatic=no + module_cmds= + module_expsym_cmds= + always_export_symbols=no + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + ld_shlibs=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + ld_shlibs=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec='-L$libdir' + allow_undefined_flag=unsupported + always_export_symbols=no + enable_shared_with_static_runtimes=yes + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + ld_shlibs=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + + sunos4*) + archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + archive_expsym_cmds="$tmp_archive_cmds" + fi + else + ld_shlibs=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + + if test "$ld_shlibs" = yes; then + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag=unsupported + always_export_symbols=yes + archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds='' + hardcode_direct=yes + hardcode_libdir_separator=':' + link_all_deplibs=yes + + if test "$GCC" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct=yes + else + # We have old collect2 + hardcode_direct=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L=yes + hardcode_libdir_flag_spec='-L$libdir' + hardcode_libdir_separator= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag="-z nodefs" + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag=' ${wl}-bernotok' + allow_undefined_flag=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec=' ' + archive_cmds_need_lc=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + # see comment about different semantics on the GNU ld section + ld_shlibs=no + ;; + + bsdi4*) + export_dynamic_flag_spec=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_From_new_cmds='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + enable_shared_with_static_runtimes=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + archive_cmds_need_lc=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + whole_archive_flag_spec='-all_load $convenience' + link_all_deplibs=yes + else + ld_shlibs=no + fi + ;; + + dgux*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + freebsd1*) + ld_shlibs=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + export_dynamic_flag_spec='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld='+b $libdir' + hardcode_libdir_separator=: + hardcode_direct=no + hardcode_shlibpath_var=no + ;; + ia64*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=no + hardcode_shlibpath_var=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + *) + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + export_dynamic_flag_spec='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_ld='-rpath $libdir' + fi + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + link_all_deplibs=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + newsos6) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_shlibpath_var=no + ;; + + openbsd*) + hardcode_direct=yes + hardcode_shlibpath_var=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-R$libdir' + ;; + *) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + allow_undefined_flag=unsupported + archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_From_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec='-rpath $libdir' + fi + hardcode_libdir_separator=: + ;; + + sco3.2v5*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + no_undefined_flag=' -z text' + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_shlibpath_var=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;; + esac + link_all_deplibs=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds='$CC -r -o $output$reload_objs' + hardcode_direct=no + ;; + motorola) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv4.3*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs=yes + fi + ;; + + sysv4.2uw2*) + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=no + hardcode_shlibpath_var=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + no_undefined_flag='${wl}-z ${wl}text' + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv5*) + no_undefined_flag=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + hardcode_libdir_flag_spec= + hardcode_shlibpath_var=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + *) + ld_shlibs=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +$as_echo "$ld_shlibs" >&6; } +test "$ld_shlibs" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag + allow_undefined_flag= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc=no + else + archive_cmds_need_lc=yes + fi + allow_undefined_flag=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc" >&5 +$as_echo "$archive_cmds_need_lc" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action= +if test -n "$hardcode_libdir_flag_spec" || \ + test -n "$runpath_var " || \ + test "X$hardcode_automatic"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, )" != no && + test "$hardcode_minus_L" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +$as_echo "$hardcode_action" >&6; } + +if test "$hardcode_action" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + +# Report which librarie types wil actually be built +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } +test "$can_build_shared" = "no" && enable_shared=no + +# On AIX, shared libraries and static libraries use the same namespace, and +# are all built from PIC. +case "$host_os" in +aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + +aix4* | aix5*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + darwin* | rhapsody*) + if test "$GCC" = yes; then + archive_cmds_need_lc=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + output_verbose_link_cmd='echo' + archive_cmds='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring' + module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + module_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + whole_archive_flag_spec='-all_load $convenience' + link_all_deplibs=yes + else + ld_shlibs=no + fi + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } +# Make sure either enable_shared or enable_static is yes. +test "$enable_shared" = yes || enable_static=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler \ + CC \ + LD \ + lt_prog_compiler_wl \ + lt_prog_compiler_pic \ + lt_prog_compiler_static \ + lt_prog_compiler_no_builtin_flag \ + export_dynamic_flag_spec \ + thread_safe_flag_spec \ + whole_archive_flag_spec \ + enable_shared_with_static_runtimes \ + old_archive_cmds \ + old_archive_from_new_cmds \ + predep_objects \ + postdep_objects \ + predeps \ + postdeps \ + compiler_lib_search_path \ + archive_cmds \ + archive_expsym_cmds \ + postinstall_cmds \ + postuninstall_cmds \ + old_archive_from_expsyms_cmds \ + allow_undefined_flag \ + no_undefined_flag \ + export_symbols_cmds \ + hardcode_libdir_flag_spec \ + hardcode_libdir_flag_spec_ld \ + hardcode_libdir_separator \ + hardcode_automatic \ + module_cmds \ + module_expsym_cmds \ + lt_cv_prog_compiler_c_o \ + exclude_expsyms \ + include_expsyms; do + + case $var in + old_archive_cmds | \ + old_archive_from_new_cmds | \ + archive_cmds | \ + archive_expsym_cmds | \ + module_cmds | \ + module_expsym_cmds | \ + old_archive_from_expsyms_cmds | \ + export_symbols_cmds | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="${ofile}T" + trap "$rm \"$cfgfile\"; exit 1" 1 2 15 + $rm -f "$cfgfile" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ofile" >&5 +$as_echo "$as_me: creating $ofile" >&6;} + + cat <<__EOF__ >> "$cfgfile" +#! $SHELL + +# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP) +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 +# Free Software Foundation, Inc. +# +# This file is part of GNU Libtool: +# Originally by Gordon Matzigkeit , 1996 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="$SED -e s/^X//" + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi + +# The names of the tagged configurations supported by this script. +available_tags= + +# ### BEGIN LIBTOOL CONFIG + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU C compiler? +with_gcc=$GCC + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# ### END LIBTOOL CONFIG + +__EOF__ + + + case $host_os in + aix3*) + cat <<\EOF >> "$cfgfile" + +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +EOF + ;; + esac + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1) + + mv -f "$cfgfile" "$ofile" || \ + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + +@%:@ Check whether --with-tags was given. +if test "${with_tags+set}" = set; then : + withval=$with_tags; tagnames="$withval" +fi + + +if test -f "$ltmain" && test -n "$tagnames"; then + if test ! -f "${ofile}"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: output file \`$ofile' does not exist" >&5 +$as_echo "$as_me: WARNING: output file \`$ofile' does not exist" >&2;} + fi + + if test -z "$LTCC"; then + eval "`$SHELL ${ofile} --config | grep '^LTCC='`" + if test -z "$LTCC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: output file \`$ofile' does not look like a libtool script" >&5 +$as_echo "$as_me: WARNING: output file \`$ofile' does not look like a libtool script" >&2;} + else + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&5 +$as_echo "$as_me: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&2;} + fi + fi + + # Extract list of available tagged configurations in $ofile. + # Note that this assumes the entire list is on one line. + available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'` + + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for tagname in $tagnames; do + IFS="$lt_save_ifs" + # Check whether tagname contains only valid characters + case `$echo "X$tagname" | $Xsed -e 's:[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]::g'` in + "") ;; + *) as_fn_error $? "invalid tag name: $tagname" "$LINENO" 5 + ;; + esac + + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null + then + as_fn_error $? "tag name \"$tagname\" already exists" "$LINENO" 5 + fi + + # Update the list of available tags. + if test -n "$tagname"; then + echo appending configuration tag \"$tagname\" to $ofile + + case $tagname in + CXX) + if test -n "$CXX" && test "X$CXX" != "Xno"; then + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + + +archive_cmds_need_lc_CXX=no +allow_undefined_flag_CXX= +always_export_symbols_CXX=no +archive_expsym_cmds_CXX= +export_dynamic_flag_spec_CXX= +hardcode_direct_CXX=no +hardcode_libdir_flag_spec_CXX= +hardcode_libdir_flag_spec_ld_CXX= +hardcode_libdir_separator_CXX= +hardcode_minus_L_CXX=no +hardcode_automatic_CXX=no +module_cmds_CXX= +module_expsym_cmds_CXX= +link_all_deplibs_CXX=unknown +old_archive_cmds_CXX=$old_archive_cmds +no_undefined_flag_CXX= +whole_archive_flag_spec_CXX= +enable_shared_with_static_runtimes_CXX=no + +# Dependencies to place before and after the object being linked: +predep_objects_CXX= +postdep_objects_CXX= +predeps_CXX= +postdeps_CXX= +compiler_lib_search_path_CXX= + +# Source file extension for C++ test sources. +ac_ext=cc + +# Object file extension for compiled C++ test sources. +objext=o +objext_CXX=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(int, char *) { return(0); }\n' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_LD=$LD +lt_save_GCC=$GCC +GCC=$GXX +lt_save_with_gnu_ld=$with_gnu_ld +lt_save_path_LD=$lt_cv_path_LD +if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx +else + unset lt_cv_prog_gnu_ld +fi +if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX +else + unset lt_cv_path_LD +fi +test -z "${LDCXX+set}" || LD=$LDCXX +CC=${CXX-"c++"} +compiler=$CC +compiler_CXX=$CC +cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'` + +# We don't want -fno-exception wen compiling C++ code, so set the +# no_builtin_flag separately +if test "$GXX" = yes; then + lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' +else + lt_prog_compiler_no_builtin_flag_CXX= +fi + +if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + +@%:@ Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'` + while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do + ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some GNU ld's only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU ld's only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | \ + grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_CXX= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + +else + GXX=no + with_gnu_ld=no + wlarc= +fi + +# PORTME: fill in a description of your system's C++ link characteristics +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } +ld_shlibs_CXX=yes +case $host_os in + aix3*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_CXX='' + hardcode_direct_CXX=yes + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + + if test "$GXX" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct_CXX=yes + else + # We have old collect2 + hardcode_direct_CXX=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_CXX=yes + hardcode_libdir_flag_spec_CXX='-L$libdir' + hardcode_libdir_separator_CXX= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols_CXX=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_CXX='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + + archive_expsym_cmds_CXX="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_CXX="-z nodefs" + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_CXX=' ${wl}-bernotok' + allow_undefined_flag_CXX=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols_CXX=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_CXX=' ' + archive_cmds_need_lc_CXX=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_CXX='-L$libdir' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=no + enable_shared_with_static_runtimes_CXX=yes + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs_CXX=no + fi + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes; then + archive_cmds_need_lc_CXX=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag_CXX='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag_CXX='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag_CXX='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag_CXX='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds_CXX='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds_CXX='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds_CXX='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct_CXX=no + hardcode_automatic_CXX=yes + hardcode_shlibpath_var_CXX=unsupported + whole_archive_flag_spec_CXX='-all_load $convenience' + link_all_deplibs_CXX=yes + else + ld_shlibs_CXX=no + fi + ;; + + dgux*) + case $cc_basename in + ec++) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + ghcx) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + freebsd12*) + # C++ shared libraries reported to be fairly broken before switch to ELF + ld_shlibs_CXX=no + ;; + freebsd-elf*) + archive_cmds_need_lc_CXX=no + ;; + freebsd* | kfreebsd*-gnu) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + ld_shlibs_CXX=yes + ;; + gnu*) + ;; + hpux9*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC) + archive_cmds_CXX='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes; then + archive_cmds_CXX='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld_CXX='+b $libdir' + hardcode_libdir_separator_CXX=: + ;; + ia64*) + hardcode_libdir_flag_spec_CXX='-L$libdir' + ;; + *) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + ;; + esac + fi + case "$host_cpu" in + hppa*64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + ;; + ia64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + *) + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC) + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_CXX='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs' + ;; + *) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case "$host_cpu" in + ia64*|hppa*64*) + archive_cmds_CXX='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs' + ;; + *) + archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + irix5* | irix6*) + case $cc_basename in + CC) + # SGI C++ + archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + else + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib' + fi + fi + link_all_deplibs_CXX=yes + ;; + esac + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + ;; + linux*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + + hardcode_libdir_flag_spec_CXX='${wl}--rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc) + # Intel C++ + with_gnu_ld=yes + archive_cmds_need_lc_CXX=no + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + cxx) + # Compaq C++ + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + esac + ;; + lynxos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + m88k*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + mvs*) + case $cc_basename in + cxx) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + osf3*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + + ;; + RCC) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx) + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + osf4* | osf5*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' + ;; + RCC) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx) + allow_undefined_flag_CXX=' -expect_unresolved \*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp `test -n "$verstring" && echo -set_version $verstring` -update_registry $objdir/so_locations -o $lib~ + $rm $lib.exp' + + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + psos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + sco*) + archive_cmds_need_lc_CXX=no + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + lcc) + # Lucid + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + solaris*) + case $cc_basename in + CC) + # Sun C++ 4.2, 5.x and Centerline C++ + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_shlibpath_var_CXX=no + case $host_os in + solaris2.0-5 | solaris2.0-5.*) ;; + *) + # The C++ compiler is used as linker so we must use $wl + # flag to pass the commands to the underlying system + # linker. + # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + link_all_deplibs_CXX=yes + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep "\-[LR]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + gcx) + # Green Hills C++ Compiler + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + no_undefined_flag_CXX=' ${wl}-z ${wl}defs' + if $CC --version | grep -v '^2\.7' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\"" + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\"" + fi + + hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir' + fi + ;; + esac + ;; + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + archive_cmds_need_lc_CXX=no + ;; + tandem*) + case $cc_basename in + NCC) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + vxworks*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +GCC_CXX="$GXX" +LD_CXX="$LD" + + +cat > conftest.$ac_ext <&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + # The `*' in the case matches for architectures that use `case' in + # $output_verbose_cmd can trigger glob expansion during the loop + # eval without this substitution. + output_verbose_link_cmd="`$echo \"X$output_verbose_link_cmd\" | $Xsed -e \"$no_glob_subst\"`" + + for p in `eval $output_verbose_link_cmd`; do + case $p in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" \ + || test $p = "-R"; then + prev=$p + continue + else + prev= + fi + + if test "$pre_test_object_deps_done" = no; then + case $p in + -L* | -R*) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$compiler_lib_search_path_CXX"; then + compiler_lib_search_path_CXX="${prev}${p}" + else + compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$postdeps_CXX"; then + postdeps_CXX="${prev}${p}" + else + postdeps_CXX="${postdeps_CXX} ${prev}${p}" + fi + fi + ;; + + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$predep_objects_CXX"; then + predep_objects_CXX="$p" + else + predep_objects_CXX="$predep_objects_CXX $p" + fi + else + if test -z "$postdep_objects_CXX"; then + postdep_objects_CXX="$p" + else + postdep_objects_CXX="$postdep_objects_CXX $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling CXX test program" +fi + +$rm -f confest.$objext + +case " $postdeps_CXX " in +*" -lc "*) archive_cmds_need_lc_CXX=no ;; +esac + +lt_prog_compiler_wl_CXX= +lt_prog_compiler_pic_CXX= +lt_prog_compiler_static_CXX= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + fi + ;; + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4' + ;; + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | os2* | pw32*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_CXX='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + lt_prog_compiler_pic_CXX= + ;; + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_CXX=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + else + case $host_os in + aix4* | aix5*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + else + lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68) + # Green Hills C++ Compiler + # _LT_AC_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + dgux*) + case $cc_basename in + ec++) + lt_prog_compiler_pic_CXX='-KPIC' + ;; + ghcx) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | kfreebsd*-gnu) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive" + if test "$host_cpu" != ia64; then + lt_prog_compiler_pic_CXX='+Z' + fi + ;; + aCC) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive" + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_CXX='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux*) + case $cc_basename in + KCC) + # KAI C++ Compiler + lt_prog_compiler_wl_CXX='--backend -Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + ;; + icpc) + # Intel C++ + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-static' + ;; + cxx) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx) + lt_prog_compiler_pic_CXX='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd*) + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC) + lt_prog_compiler_wl_CXX='--backend -Wl,' + ;; + RCC) + # Rational C++ 2.4.1 + lt_prog_compiler_pic_CXX='-pic' + ;; + cxx) + # Digital/Compaq C++ + lt_prog_compiler_wl_CXX='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + sco*) + case $cc_basename in + CC) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + *) + ;; + esac + ;; + solaris*) + case $cc_basename in + CC) + # Sun C++ 4.2, 5.x and Centerline C++ + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + gcx) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC) + # Sun C++ 4.x + lt_prog_compiler_pic_CXX='-pic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + lcc) + # Lucid + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC) + # NonStop-UX NCC 3.20 + lt_prog_compiler_pic_CXX='-KPIC' + ;; + *) + ;; + esac + ;; + unixware*) + ;; + vxworks*) + ;; + *) + lt_prog_compiler_can_build_shared_CXX=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_CXX" >&5 +$as_echo "$lt_prog_compiler_pic_CXX" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_CXX"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } +if ${lt_prog_compiler_pic_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works_CXX=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works_CXX=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works_CXX" >&5 +$as_echo "$lt_prog_compiler_pic_works_CXX" >&6; } + +if test x"$lt_prog_compiler_pic_works_CXX" = xyes; then + case $lt_prog_compiler_pic_CXX in + "" | " "*) ;; + *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;; + esac +else + lt_prog_compiler_pic_CXX= + lt_prog_compiler_can_build_shared_CXX=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_CXX= + ;; + *) + lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + case $host_os in + aix4* | aix5*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + export_symbols_cmds_CXX="$ltdll_cmds" + ;; + cygwin* | mingw*) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_CXX" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_CXX=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_CXX in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_CXX + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_CXX + allow_undefined_flag_CXX= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc_CXX=no + else + archive_cmds_need_lc_CXX=yes + fi + allow_undefined_flag_CXX=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc_CXX" >&5 +$as_echo "$archive_cmds_need_lc_CXX" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_CXX= +if test -n "$hardcode_libdir_flag_spec_CXX" || \ + test -n "$runpath_var CXX" || \ + test "X$hardcode_automatic_CXX"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct_CXX" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, CXX)" != no && + test "$hardcode_minus_L_CXX" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_CXX=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_CXX=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_CXX=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +$as_echo "$hardcode_action_CXX" >&6; } + +if test "$hardcode_action_CXX" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_cxx_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" +else + ac_fn_cxx_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_CXX \ + CC_CXX \ + LD_CXX \ + lt_prog_compiler_wl_CXX \ + lt_prog_compiler_pic_CXX \ + lt_prog_compiler_static_CXX \ + lt_prog_compiler_no_builtin_flag_CXX \ + export_dynamic_flag_spec_CXX \ + thread_safe_flag_spec_CXX \ + whole_archive_flag_spec_CXX \ + enable_shared_with_static_runtimes_CXX \ + old_archive_cmds_CXX \ + old_archive_from_new_cmds_CXX \ + predep_objects_CXX \ + postdep_objects_CXX \ + predeps_CXX \ + postdeps_CXX \ + compiler_lib_search_path_CXX \ + archive_cmds_CXX \ + archive_expsym_cmds_CXX \ + postinstall_cmds_CXX \ + postuninstall_cmds_CXX \ + old_archive_from_expsyms_cmds_CXX \ + allow_undefined_flag_CXX \ + no_undefined_flag_CXX \ + export_symbols_cmds_CXX \ + hardcode_libdir_flag_spec_CXX \ + hardcode_libdir_flag_spec_ld_CXX \ + hardcode_libdir_separator_CXX \ + hardcode_automatic_CXX \ + module_cmds_CXX \ + module_expsym_cmds_CXX \ + lt_cv_prog_compiler_c_o_CXX \ + exclude_expsyms_CXX \ + include_expsyms_CXX; do + + case $var in + old_archive_cmds_CXX | \ + old_archive_from_new_cmds_CXX | \ + archive_cmds_CXX | \ + archive_expsym_cmds_CXX | \ + module_cmds_CXX | \ + module_expsym_cmds_CXX | \ + old_archive_from_expsyms_cmds_CXX | \ + export_symbols_cmds_CXX | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_CXX + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_CXX + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_CXX +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_CXX + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_CXX + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_CXX + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_CXX + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_CXX" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC=$lt_save_CC +LDCXX=$LD +LD=$lt_save_LD +GCC=$lt_save_GCC +with_gnu_ldcxx=$with_gnu_ld +with_gnu_ld=$lt_save_with_gnu_ld +lt_cv_path_LDCXX=$lt_cv_path_LD +lt_cv_path_LD=$lt_save_path_LD +lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld +lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld + + else + tagname="" + fi + ;; + + F77) + if test -n "$F77" && test "X$F77" != "Xno"; then + +ac_ext=f +ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5' +ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_f77_compiler_gnu + + +archive_cmds_need_lc_F77=no +allow_undefined_flag_F77= +always_export_symbols_F77=no +archive_expsym_cmds_F77= +export_dynamic_flag_spec_F77= +hardcode_direct_F77=no +hardcode_libdir_flag_spec_F77= +hardcode_libdir_flag_spec_ld_F77= +hardcode_libdir_separator_F77= +hardcode_minus_L_F77=no +hardcode_automatic_F77=no +module_cmds_F77= +module_expsym_cmds_F77= +link_all_deplibs_F77=unknown +old_archive_cmds_F77=$old_archive_cmds +no_undefined_flag_F77= +whole_archive_flag_spec_F77= +enable_shared_with_static_runtimes_F77=no + +# Source file extension for f77 test sources. +ac_ext=f + +# Object file extension for compiled f77 test sources. +objext=o +objext_F77=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code=" subroutine t\n return\n end\n" + +# Code to be used in simple link tests +lt_simple_link_test_code=" program t\n end\n" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +CC=${F77-"f77"} +compiler=$CC +compiler_F77=$CC +cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'` + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } +test "$can_build_shared" = "no" && enable_shared=no + +# On AIX, shared libraries and static libraries use the same namespace, and +# are all built from PIC. +case "$host_os" in +aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; +aix4* | aix5*) + test "$enable_shared" = yes && enable_static=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } +# Make sure either enable_shared or enable_static is yes. +test "$enable_shared" = yes || enable_static=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + +test "$ld_shlibs_F77" = no && can_build_shared=no + +GCC_F77="$G77" +LD_F77="$LD" + +lt_prog_compiler_wl_F77= +lt_prog_compiler_pic_F77= +lt_prog_compiler_static_F77= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + if test "$GCC" = yes; then + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_static_F77='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_F77='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_F77='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_F77='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_F77='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared_F77=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_F77=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_F77='-fPIC' + ;; + esac + ;; + + *) + lt_prog_compiler_pic_F77='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl_F77='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_F77='-Bstatic' + else + lt_prog_compiler_static_F77='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_F77='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl_F77='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_F77='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static_F77='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl_F77='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static_F77='-non_shared' + ;; + + newsos6) + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-static' + ;; + ccc*) + lt_prog_compiler_wl_F77='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static_F77='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl_F77='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static_F77='-non_shared' + ;; + + sco3.2v5*) + lt_prog_compiler_pic_F77='-Kpic' + lt_prog_compiler_static_F77='-dn' + ;; + + solaris*) + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + sunos4*) + lt_prog_compiler_wl_F77='-Qoption ld ' + lt_prog_compiler_pic_F77='-PIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic_F77='-Kconform_pic' + lt_prog_compiler_static_F77='-Bstatic' + fi + ;; + + uts4*) + lt_prog_compiler_pic_F77='-pic' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared_F77=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_F77" >&5 +$as_echo "$lt_prog_compiler_pic_F77" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_F77"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works... " >&6; } +if ${lt_prog_compiler_pic_works_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works_F77=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_F77" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works_F77=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works_F77" >&5 +$as_echo "$lt_prog_compiler_pic_works_F77" >&6; } + +if test x"$lt_prog_compiler_pic_works_F77" = xyes; then + case $lt_prog_compiler_pic_F77 in + "" | " "*) ;; + *) lt_prog_compiler_pic_F77=" $lt_prog_compiler_pic_F77" ;; + esac +else + lt_prog_compiler_pic_F77= + lt_prog_compiler_can_build_shared_F77=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_F77= + ;; + *) + lt_prog_compiler_pic_F77="$lt_prog_compiler_pic_F77" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_F77=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o_F77=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_F77" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_F77" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_F77" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag_F77= + enable_shared_with_static_runtimes_F77=no + archive_cmds_F77= + archive_expsym_cmds_F77= + old_archive_From_new_cmds_F77= + old_archive_from_expsyms_cmds_F77= + export_dynamic_flag_spec_F77= + whole_archive_flag_spec_F77= + thread_safe_flag_spec_F77= + hardcode_libdir_flag_spec_F77= + hardcode_libdir_flag_spec_ld_F77= + hardcode_libdir_separator_F77= + hardcode_direct_F77=no + hardcode_minus_L_F77=no + hardcode_shlibpath_var_F77=unsupported + link_all_deplibs_F77=unknown + hardcode_automatic_F77=no + module_cmds_F77= + module_expsym_cmds_F77= + always_export_symbols_F77=no + export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms_F77= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms_F77="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + ld_shlibs_F77=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs_F77=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_minus_L_F77=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + ld_shlibs_F77=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_F77=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_F77='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_F77=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, F77) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_F77='-L$libdir' + allow_undefined_flag_F77=unsupported + always_export_symbols_F77=no + enable_shared_with_static_runtimes_F77=yes + export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_F77='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_F77='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + ld_shlibs_F77=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_F77=no + fi + ;; + + sunos4*) + archive_cmds_F77='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds_F77="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + archive_expsym_cmds_F77='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + archive_expsym_cmds_F77="$tmp_archive_cmds" + fi + else + ld_shlibs_F77=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_F77=no + fi + ;; + esac + + if test "$ld_shlibs_F77" = yes; then + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_F77='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_F77='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_F77="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_F77= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag_F77=unsupported + always_export_symbols_F77=yes + archive_expsym_cmds_F77='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L_F77=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct_F77=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds_F77='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_F77='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_F77='' + hardcode_direct_F77=yes + hardcode_libdir_separator_F77=':' + link_all_deplibs_F77=yes + + if test "$GCC" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct_F77=yes + else + # We have old collect2 + hardcode_direct_F77=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_F77=yes + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_libdir_separator_F77= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols_F77=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_F77='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat > conftest.$ac_ext <<_ACEOF + program main + + end +_ACEOF +if ac_fn_f77_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds_F77="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_F77='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_F77="-z nodefs" + archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat > conftest.$ac_ext <<_ACEOF + program main + + end +_ACEOF +if ac_fn_f77_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_F77=' ${wl}-bernotok' + allow_undefined_flag_F77=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols_F77=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_F77=' ' + archive_cmds_need_lc_F77=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_minus_L_F77=yes + # see comment about different semantics on the GNU ld section + ld_shlibs_F77=no + ;; + + bsdi4*) + export_dynamic_flag_spec_F77=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_F77=' ' + allow_undefined_flag_F77=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_F77='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_From_new_cmds_F77='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds_F77='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + enable_shared_with_static_runtimes_F77=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + archive_cmds_need_lc_F77=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag_F77='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag_F77='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag_F77='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag_F77='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds_F77='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds_F77='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds_F77='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct_F77=no + hardcode_automatic_F77=yes + hardcode_shlibpath_var_F77=unsupported + whole_archive_flag_spec_F77='-all_load $convenience' + link_all_deplibs_F77=yes + else + ld_shlibs_F77=no + fi + ;; + + dgux*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_shlibpath_var_F77=no + ;; + + freebsd1*) + ld_shlibs_F77=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes + hardcode_minus_L_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + archive_cmds_F77='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds_F77='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds_F77='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_F77=: + hardcode_direct_F77=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_F77=yes + export_dynamic_flag_spec_F77='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_F77='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_F77='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_F77='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + archive_cmds_F77='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld_F77='+b $libdir' + hardcode_libdir_separator_F77=: + hardcode_direct_F77=no + hardcode_shlibpath_var_F77=no + ;; + ia64*) + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_direct_F77=no + hardcode_shlibpath_var_F77=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_F77=yes + ;; + *) + hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_F77=: + hardcode_direct_F77=yes + export_dynamic_flag_spec_F77='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_F77=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_F77='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_ld_F77='-rpath $libdir' + fi + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_F77=: + link_all_deplibs_F77=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds_F77='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + newsos6) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_F77=: + hardcode_shlibpath_var_F77=no + ;; + + openbsd*) + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir' + export_dynamic_flag_spec_F77='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_F77='-R$libdir' + ;; + *) + archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_minus_L_F77=yes + allow_undefined_flag_F77=unsupported + archive_cmds_F77='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_From_new_cmds_F77='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag_F77=' -expect_unresolved \*' + archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_F77=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag_F77=' -expect_unresolved \*' + archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_F77='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec_F77='-rpath $libdir' + fi + hardcode_libdir_separator_F77=: + ;; + + sco3.2v5*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_F77=no + export_dynamic_flag_spec_F77='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + no_undefined_flag_F77=' -z text' + if test "$GCC" = yes; then + archive_cmds_F77='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + archive_cmds_F77='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_shlibpath_var_F77=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_F77='-z allextract$convenience -z defaultextract' ;; + esac + link_all_deplibs_F77=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds_F77='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_F77='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_direct_F77=yes + hardcode_minus_L_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds_F77='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds_F77='$CC -r -o $output$reload_objs' + hardcode_direct_F77=no + ;; + motorola) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_F77=no + ;; + + sysv4.3*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_F77=no + export_dynamic_flag_spec_F77='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_F77=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs_F77=yes + fi + ;; + + sysv4.2uw2*) + archive_cmds_F77='$LD -G -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes + hardcode_minus_L_F77=no + hardcode_shlibpath_var_F77=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + no_undefined_flag_F77='${wl}-z ${wl}text' + if test "$GCC" = yes; then + archive_cmds_F77='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_F77='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_F77=no + ;; + + sysv5*) + no_undefined_flag_F77=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + archive_cmds_F77='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + hardcode_libdir_flag_spec_F77= + hardcode_shlibpath_var_F77=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_shlibpath_var_F77=no + ;; + + *) + ld_shlibs_F77=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_F77" >&5 +$as_echo "$ld_shlibs_F77" >&6; } +test "$ld_shlibs_F77" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_F77" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_F77=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_F77 in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_F77 + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_F77 + allow_undefined_flag_F77= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc_F77=no + else + archive_cmds_need_lc_F77=yes + fi + allow_undefined_flag_F77=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc_F77" >&5 +$as_echo "$archive_cmds_need_lc_F77" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_F77= +if test -n "$hardcode_libdir_flag_spec_F77" || \ + test -n "$runpath_var F77" || \ + test "X$hardcode_automatic_F77"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct_F77" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, F77)" != no && + test "$hardcode_minus_L_F77" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_F77=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_F77=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_F77=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_F77" >&5 +$as_echo "$hardcode_action_F77" >&6; } + +if test "$hardcode_action_F77" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + + + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_F77 \ + CC_F77 \ + LD_F77 \ + lt_prog_compiler_wl_F77 \ + lt_prog_compiler_pic_F77 \ + lt_prog_compiler_static_F77 \ + lt_prog_compiler_no_builtin_flag_F77 \ + export_dynamic_flag_spec_F77 \ + thread_safe_flag_spec_F77 \ + whole_archive_flag_spec_F77 \ + enable_shared_with_static_runtimes_F77 \ + old_archive_cmds_F77 \ + old_archive_from_new_cmds_F77 \ + predep_objects_F77 \ + postdep_objects_F77 \ + predeps_F77 \ + postdeps_F77 \ + compiler_lib_search_path_F77 \ + archive_cmds_F77 \ + archive_expsym_cmds_F77 \ + postinstall_cmds_F77 \ + postuninstall_cmds_F77 \ + old_archive_from_expsyms_cmds_F77 \ + allow_undefined_flag_F77 \ + no_undefined_flag_F77 \ + export_symbols_cmds_F77 \ + hardcode_libdir_flag_spec_F77 \ + hardcode_libdir_flag_spec_ld_F77 \ + hardcode_libdir_separator_F77 \ + hardcode_automatic_F77 \ + module_cmds_F77 \ + module_expsym_cmds_F77 \ + lt_cv_prog_compiler_c_o_F77 \ + exclude_expsyms_F77 \ + include_expsyms_F77; do + + case $var in + old_archive_cmds_F77 | \ + old_archive_from_new_cmds_F77 | \ + archive_cmds_F77 | \ + archive_expsym_cmds_F77 | \ + module_cmds_F77 | \ + module_expsym_cmds_F77 | \ + old_archive_from_expsyms_cmds_F77 | \ + export_symbols_cmds_F77 | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_F77 + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_F77 + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_F77 + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_F77 + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_F77 + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_F77 + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_F77 +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_F77 + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_F77 + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_F77 + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_F77 + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_F77 + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_F77 + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_F77 +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_F77 + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_F77 + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_F77 +archive_expsym_cmds=$lt_archive_expsym_cmds_F77 +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_F77 +module_expsym_cmds=$lt_module_expsym_cmds_F77 + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_F77 + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_F77 + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_F77 + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_F77 + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_F77 + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_F77 + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_F77 + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_F77 + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_F77 + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_F77 + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_F77 + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_F77 + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_F77 + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_F77 + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_F77 + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_F77 + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_F77" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_F77 + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_F77 + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_F77 + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_F77 + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + else + tagname="" + fi + ;; + + GCJ) + if test -n "$GCJ" && test "X$GCJ" != "Xno"; then + + +# Source file extension for Java test sources. +ac_ext=java + +# Object file extension for compiled Java test sources. +objext=o +objext_GCJ=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="class foo {}\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='public class conftest { public static void main(String argv) {}; }\n' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +CC=${GCJ-"gcj"} +compiler=$CC +compiler_GCJ=$CC + +# GCJ did not exist at the time GCC didn't implicitly link libc in. +archive_cmds_need_lc_GCJ=no + + +lt_prog_compiler_no_builtin_flag_GCJ= + +if test "$GCC" = yes; then + lt_prog_compiler_no_builtin_flag_GCJ=' -fno-builtin' + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag_GCJ="$lt_prog_compiler_no_builtin_flag_GCJ -fno-rtti -fno-exceptions" +else + : +fi + +fi + +lt_prog_compiler_wl_GCJ= +lt_prog_compiler_pic_GCJ= +lt_prog_compiler_static_GCJ= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + if test "$GCC" = yes; then + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_static_GCJ='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_GCJ='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_GCJ='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_GCJ='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_GCJ='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared_GCJ=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_GCJ=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_GCJ='-fPIC' + ;; + esac + ;; + + *) + lt_prog_compiler_pic_GCJ='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl_GCJ='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_GCJ='-Bstatic' + else + lt_prog_compiler_static_GCJ='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_GCJ='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl_GCJ='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_GCJ='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static_GCJ='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl_GCJ='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static_GCJ='-non_shared' + ;; + + newsos6) + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-static' + ;; + ccc*) + lt_prog_compiler_wl_GCJ='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static_GCJ='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl_GCJ='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static_GCJ='-non_shared' + ;; + + sco3.2v5*) + lt_prog_compiler_pic_GCJ='-Kpic' + lt_prog_compiler_static_GCJ='-dn' + ;; + + solaris*) + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + sunos4*) + lt_prog_compiler_wl_GCJ='-Qoption ld ' + lt_prog_compiler_pic_GCJ='-PIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic_GCJ='-Kconform_pic' + lt_prog_compiler_static_GCJ='-Bstatic' + fi + ;; + + uts4*) + lt_prog_compiler_pic_GCJ='-pic' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared_GCJ=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_GCJ" >&5 +$as_echo "$lt_prog_compiler_pic_GCJ" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_GCJ"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works... " >&6; } +if ${lt_prog_compiler_pic_works_GCJ+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works_GCJ=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_GCJ" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works_GCJ=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works_GCJ" >&5 +$as_echo "$lt_prog_compiler_pic_works_GCJ" >&6; } + +if test x"$lt_prog_compiler_pic_works_GCJ" = xyes; then + case $lt_prog_compiler_pic_GCJ in + "" | " "*) ;; + *) lt_prog_compiler_pic_GCJ=" $lt_prog_compiler_pic_GCJ" ;; + esac +else + lt_prog_compiler_pic_GCJ= + lt_prog_compiler_can_build_shared_GCJ=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_GCJ= + ;; + *) + lt_prog_compiler_pic_GCJ="$lt_prog_compiler_pic_GCJ" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_GCJ+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_GCJ=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:__oline__: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o_GCJ=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_GCJ" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_GCJ" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_GCJ" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag_GCJ= + enable_shared_with_static_runtimes_GCJ=no + archive_cmds_GCJ= + archive_expsym_cmds_GCJ= + old_archive_From_new_cmds_GCJ= + old_archive_from_expsyms_cmds_GCJ= + export_dynamic_flag_spec_GCJ= + whole_archive_flag_spec_GCJ= + thread_safe_flag_spec_GCJ= + hardcode_libdir_flag_spec_GCJ= + hardcode_libdir_flag_spec_ld_GCJ= + hardcode_libdir_separator_GCJ= + hardcode_direct_GCJ=no + hardcode_minus_L_GCJ=no + hardcode_shlibpath_var_GCJ=unsupported + link_all_deplibs_GCJ=unknown + hardcode_automatic_GCJ=no + module_cmds_GCJ= + module_expsym_cmds_GCJ= + always_export_symbols_GCJ=no + export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms_GCJ= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms_GCJ="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + ld_shlibs_GCJ=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs_GCJ=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_minus_L_GCJ=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + ld_shlibs_GCJ=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_GCJ=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_GCJ='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_GCJ=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, GCJ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_GCJ='-L$libdir' + allow_undefined_flag_GCJ=unsupported + always_export_symbols_GCJ=no + enable_shared_with_static_runtimes_GCJ=yes + export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_GCJ='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_GCJ='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + ld_shlibs_GCJ=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_GCJ=no + fi + ;; + + sunos4*) + archive_cmds_GCJ='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds_GCJ="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + archive_expsym_cmds_GCJ='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + archive_expsym_cmds_GCJ="$tmp_archive_cmds" + fi + else + ld_shlibs_GCJ=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_GCJ=no + fi + ;; + esac + + if test "$ld_shlibs_GCJ" = yes; then + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_GCJ='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_GCJ='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_GCJ="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_GCJ= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag_GCJ=unsupported + always_export_symbols_GCJ=yes + archive_expsym_cmds_GCJ='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L_GCJ=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct_GCJ=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds_GCJ='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_GCJ='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_GCJ='' + hardcode_direct_GCJ=yes + hardcode_libdir_separator_GCJ=':' + link_all_deplibs_GCJ=yes + + if test "$GCC" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct_GCJ=yes + else + # We have old collect2 + hardcode_direct_GCJ=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_GCJ=yes + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_libdir_separator_GCJ= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols_GCJ=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_GCJ='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds_GCJ="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_GCJ='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_GCJ="-z nodefs" + archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_GCJ=' ${wl}-bernotok' + allow_undefined_flag_GCJ=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols_GCJ=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_GCJ=' ' + archive_cmds_need_lc_GCJ=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_minus_L_GCJ=yes + # see comment about different semantics on the GNU ld section + ld_shlibs_GCJ=no + ;; + + bsdi4*) + export_dynamic_flag_spec_GCJ=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_GCJ=' ' + allow_undefined_flag_GCJ=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_GCJ='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_From_new_cmds_GCJ='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds_GCJ='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + enable_shared_with_static_runtimes_GCJ=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + archive_cmds_need_lc_GCJ=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag_GCJ='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag_GCJ='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag_GCJ='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag_GCJ='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds_GCJ='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds_GCJ='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds_GCJ='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct_GCJ=no + hardcode_automatic_GCJ=yes + hardcode_shlibpath_var_GCJ=unsupported + whole_archive_flag_spec_GCJ='-all_load $convenience' + link_all_deplibs_GCJ=yes + else + ld_shlibs_GCJ=no + fi + ;; + + dgux*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_shlibpath_var_GCJ=no + ;; + + freebsd1*) + ld_shlibs_GCJ=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes + hardcode_minus_L_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + archive_cmds_GCJ='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds_GCJ='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds_GCJ='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + hardcode_direct_GCJ=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_GCJ=yes + export_dynamic_flag_spec_GCJ='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_GCJ='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_GCJ='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_GCJ='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + archive_cmds_GCJ='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld_GCJ='+b $libdir' + hardcode_libdir_separator_GCJ=: + hardcode_direct_GCJ=no + hardcode_shlibpath_var_GCJ=no + ;; + ia64*) + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_direct_GCJ=no + hardcode_shlibpath_var_GCJ=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_GCJ=yes + ;; + *) + hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + hardcode_direct_GCJ=yes + export_dynamic_flag_spec_GCJ='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_GCJ=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_GCJ='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_ld_GCJ='-rpath $libdir' + fi + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + link_all_deplibs_GCJ=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds_GCJ='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + newsos6) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + hardcode_shlibpath_var_GCJ=no + ;; + + openbsd*) + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir' + export_dynamic_flag_spec_GCJ='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_GCJ='-R$libdir' + ;; + *) + archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_minus_L_GCJ=yes + allow_undefined_flag_GCJ=unsupported + archive_cmds_GCJ='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_From_new_cmds_GCJ='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag_GCJ=' -expect_unresolved \*' + archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag_GCJ=' -expect_unresolved \*' + archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_GCJ='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec_GCJ='-rpath $libdir' + fi + hardcode_libdir_separator_GCJ=: + ;; + + sco3.2v5*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_GCJ=no + export_dynamic_flag_spec_GCJ='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + no_undefined_flag_GCJ=' -z text' + if test "$GCC" = yes; then + archive_cmds_GCJ='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + archive_cmds_GCJ='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_shlibpath_var_GCJ=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_GCJ='-z allextract$convenience -z defaultextract' ;; + esac + link_all_deplibs_GCJ=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds_GCJ='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_GCJ='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_direct_GCJ=yes + hardcode_minus_L_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds_GCJ='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds_GCJ='$CC -r -o $output$reload_objs' + hardcode_direct_GCJ=no + ;; + motorola) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_GCJ=no + ;; + + sysv4.3*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_GCJ=no + export_dynamic_flag_spec_GCJ='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_GCJ=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs_GCJ=yes + fi + ;; + + sysv4.2uw2*) + archive_cmds_GCJ='$LD -G -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes + hardcode_minus_L_GCJ=no + hardcode_shlibpath_var_GCJ=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + no_undefined_flag_GCJ='${wl}-z ${wl}text' + if test "$GCC" = yes; then + archive_cmds_GCJ='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_GCJ='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_GCJ=no + ;; + + sysv5*) + no_undefined_flag_GCJ=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + archive_cmds_GCJ='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + hardcode_libdir_flag_spec_GCJ= + hardcode_shlibpath_var_GCJ=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_shlibpath_var_GCJ=no + ;; + + *) + ld_shlibs_GCJ=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_GCJ" >&5 +$as_echo "$ld_shlibs_GCJ" >&6; } +test "$ld_shlibs_GCJ" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_GCJ" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_GCJ=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_GCJ in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_GCJ + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_GCJ + allow_undefined_flag_GCJ= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc_GCJ=no + else + archive_cmds_need_lc_GCJ=yes + fi + allow_undefined_flag_GCJ=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc_GCJ" >&5 +$as_echo "$archive_cmds_need_lc_GCJ" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_GCJ= +if test -n "$hardcode_libdir_flag_spec_GCJ" || \ + test -n "$runpath_var GCJ" || \ + test "X$hardcode_automatic_GCJ"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct_GCJ" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, GCJ)" != no && + test "$hardcode_minus_L_GCJ" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_GCJ=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_GCJ=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_GCJ=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_GCJ" >&5 +$as_echo "$hardcode_action_GCJ" >&6; } + +if test "$hardcode_action_GCJ" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_GCJ \ + CC_GCJ \ + LD_GCJ \ + lt_prog_compiler_wl_GCJ \ + lt_prog_compiler_pic_GCJ \ + lt_prog_compiler_static_GCJ \ + lt_prog_compiler_no_builtin_flag_GCJ \ + export_dynamic_flag_spec_GCJ \ + thread_safe_flag_spec_GCJ \ + whole_archive_flag_spec_GCJ \ + enable_shared_with_static_runtimes_GCJ \ + old_archive_cmds_GCJ \ + old_archive_from_new_cmds_GCJ \ + predep_objects_GCJ \ + postdep_objects_GCJ \ + predeps_GCJ \ + postdeps_GCJ \ + compiler_lib_search_path_GCJ \ + archive_cmds_GCJ \ + archive_expsym_cmds_GCJ \ + postinstall_cmds_GCJ \ + postuninstall_cmds_GCJ \ + old_archive_from_expsyms_cmds_GCJ \ + allow_undefined_flag_GCJ \ + no_undefined_flag_GCJ \ + export_symbols_cmds_GCJ \ + hardcode_libdir_flag_spec_GCJ \ + hardcode_libdir_flag_spec_ld_GCJ \ + hardcode_libdir_separator_GCJ \ + hardcode_automatic_GCJ \ + module_cmds_GCJ \ + module_expsym_cmds_GCJ \ + lt_cv_prog_compiler_c_o_GCJ \ + exclude_expsyms_GCJ \ + include_expsyms_GCJ; do + + case $var in + old_archive_cmds_GCJ | \ + old_archive_from_new_cmds_GCJ | \ + archive_cmds_GCJ | \ + archive_expsym_cmds_GCJ | \ + module_cmds_GCJ | \ + module_expsym_cmds_GCJ | \ + old_archive_from_expsyms_cmds_GCJ | \ + export_symbols_cmds_GCJ | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_GCJ + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_GCJ + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_GCJ + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_GCJ + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_GCJ + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_GCJ + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_GCJ +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_GCJ + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_GCJ + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_GCJ + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_GCJ + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_GCJ + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_GCJ + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_GCJ +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_GCJ + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_GCJ + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_GCJ +archive_expsym_cmds=$lt_archive_expsym_cmds_GCJ +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_GCJ +module_expsym_cmds=$lt_module_expsym_cmds_GCJ + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_GCJ + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_GCJ + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_GCJ + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_GCJ + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_GCJ + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_GCJ + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_GCJ + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_GCJ + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_GCJ + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_GCJ + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_GCJ + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_GCJ + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_GCJ + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_GCJ + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_GCJ + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_GCJ + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_GCJ" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_GCJ + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_GCJ + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_GCJ + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_GCJ + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + else + tagname="" + fi + ;; + + RC) + + +# Source file extension for RC test sources. +ac_ext=rc + +# Object file extension for compiled RC test sources. +objext=o +objext_RC=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n' + +# Code to be used in simple link tests +lt_simple_link_test_code="$lt_simple_compile_test_code" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +CC=${RC-"windres"} +compiler=$CC +compiler_RC=$CC +lt_cv_prog_compiler_c_o_RC=yes + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_RC \ + CC_RC \ + LD_RC \ + lt_prog_compiler_wl_RC \ + lt_prog_compiler_pic_RC \ + lt_prog_compiler_static_RC \ + lt_prog_compiler_no_builtin_flag_RC \ + export_dynamic_flag_spec_RC \ + thread_safe_flag_spec_RC \ + whole_archive_flag_spec_RC \ + enable_shared_with_static_runtimes_RC \ + old_archive_cmds_RC \ + old_archive_from_new_cmds_RC \ + predep_objects_RC \ + postdep_objects_RC \ + predeps_RC \ + postdeps_RC \ + compiler_lib_search_path_RC \ + archive_cmds_RC \ + archive_expsym_cmds_RC \ + postinstall_cmds_RC \ + postuninstall_cmds_RC \ + old_archive_from_expsyms_cmds_RC \ + allow_undefined_flag_RC \ + no_undefined_flag_RC \ + export_symbols_cmds_RC \ + hardcode_libdir_flag_spec_RC \ + hardcode_libdir_flag_spec_ld_RC \ + hardcode_libdir_separator_RC \ + hardcode_automatic_RC \ + module_cmds_RC \ + module_expsym_cmds_RC \ + lt_cv_prog_compiler_c_o_RC \ + exclude_expsyms_RC \ + include_expsyms_RC; do + + case $var in + old_archive_cmds_RC | \ + old_archive_from_new_cmds_RC | \ + archive_cmds_RC | \ + archive_expsym_cmds_RC | \ + module_cmds_RC | \ + module_expsym_cmds_RC | \ + old_archive_from_expsyms_cmds_RC | \ + export_symbols_cmds_RC | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_RC + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_RC + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_RC + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_RC + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_RC + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_RC + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_RC +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_RC + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_RC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_RC + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_RC + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_RC + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_RC + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_RC +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_RC + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_RC + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_RC +archive_expsym_cmds=$lt_archive_expsym_cmds_RC +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_RC +module_expsym_cmds=$lt_module_expsym_cmds_RC + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_RC + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_RC + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_RC + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_RC + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_RC + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_RC + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_RC + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_RC + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_RC + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_RC + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_RC + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_RC + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_RC + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_RC + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_RC + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_RC + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_RC" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_RC + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_RC + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_RC + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_RC + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + ;; + + *) + as_fn_error $? "Unsupported tag name: $tagname" "$LINENO" 5 + ;; + esac + + # Append the new tag name to the list of available tags. + if test -n "$tagname" ; then + available_tags="$available_tags $tagname" + fi + fi + done + IFS="$lt_save_ifs" + + # Now substitute the updated list of available tags. + if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then + mv "${ofile}T" "$ofile" + chmod +x "$ofile" + else + rm -f "${ofile}T" + as_fn_error $? "unable to update list of available tagged configurations." "$LINENO" 5 + fi +fi + + + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' + +# Prevent multiple expansion + + + + + + + + + + + + + + + + + + + + + +@%:@ Check whether --enable-swap-count was given. +if test "${enable_swap_count+set}" = set; then : + enableval=$enable_swap_count; +fi + +case $enable_swap_count in + yes) + +$as_echo "@%:@define SWAPCOUNT 1" >>confdefs.h + + ;; +esac + +@%:@ Check whether --enable-cache-stats was given. +if test "${enable_cache_stats+set}" = set; then : + enableval=$enable_cache_stats; +fi + +case $enable_cache_stats in + yes) + +$as_echo "@%:@define CACHESTATS 1" >>confdefs.h + + ;; +esac + + +ac_config_headers="$ac_config_headers config.h" + + +ac_config_files="$ac_config_files Makefile src/Makefile" + + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIB@&t@OBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIB@&t@OBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + +if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then + as_fn_error $? "conditional \"AMDEP\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCC\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in @%:@( + *posix*) : + set -o posix ;; @%:@( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in @%:@( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in @%:@(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +@%:@ as_fn_error STATUS ERROR [LINENO LOG_FD] +@%:@ ---------------------------------------- +@%:@ Output "`basename @S|@0`: error: ERROR" to stderr. If LINENO and LOG_FD are +@%:@ provided, also output the error to LOG_FD, referencing LINENO. Then exit the +@%:@ script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} @%:@ as_fn_error + + +@%:@ as_fn_set_status STATUS +@%:@ ----------------------- +@%:@ Set @S|@? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} @%:@ as_fn_set_status + +@%:@ as_fn_exit STATUS +@%:@ ----------------- +@%:@ Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} @%:@ as_fn_exit + +@%:@ as_fn_unset VAR +@%:@ --------------- +@%:@ Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +@%:@ as_fn_append VAR VALUE +@%:@ ---------------------- +@%:@ Append the text in VALUE to the end of the definition contained in VAR. Take +@%:@ advantage of any shell optimizations that allow amortized linear growth over +@%:@ repeated appends, instead of the typical quadratic growth present in naive +@%:@ implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +@%:@ as_fn_arith ARG... +@%:@ ------------------ +@%:@ Perform arithmetic evaluation on the ARGs, and store the result in the +@%:@ global @S|@as_val. Take advantage of shells that can avoid forks. The arguments +@%:@ must be portable across @S|@(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in @%:@((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +@%:@ as_fn_mkdir_p +@%:@ ------------- +@%:@ Create "@S|@as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} @%:@ as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +@%:@ as_fn_executable_p FILE +@%:@ ----------------------- +@%:@ Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} @%:@ as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by buddy $as_me 2.4, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" +config_headers="$ac_config_headers" +config_commands="$ac_config_commands" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Configuration commands: +$config_commands + +Report bugs to the package provider." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +buddy config.status 2.4 +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +INSTALL='$INSTALL' +AWK='$AWK' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX +@%:@@%:@ Running $as_me. @%:@@%:@ +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# +# INIT-COMMANDS +# +AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; + "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; + "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers + test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + + case $INSTALL in + [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; + esac +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +s&@INSTALL@&$ac_INSTALL&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi +# Compute "$ac_file"'s index in $config_headers. +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + "$ac_file" | "$ac_file":* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for "$ac_file"" >`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'`/stamp-h$_am_stamp_count + ;; + + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +$as_echo "$as_me: executing $ac_file commands" >&6;} + ;; + esac + + + case $ac_file$ac_mode in + "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named `Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # So let's grep whole file. + if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then + dirpart=`$as_dirname -- "$mf" || +$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$mf" : 'X\(//\)[^/]' \| \ + X"$mf" : 'X\(//\)$' \| \ + X"$mf" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$mf" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + else + continue + fi + grep '^DEP_FILES *= *[^ @%:@]' < "$mf" > /dev/null || continue + # Extract the definition of DEP_FILES from the Makefile without + # running `make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + # When using ansi2knr, U may be empty or an underscore; expand it + U=`sed -n 's/^U = //p' < "$mf"` + test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR" + # We invoke sed twice because it is the simplest approach to + # changing $(DEPDIR) to its actual value in the expansion. + for file in `sed -n ' + /^DEP_FILES = .*\\\\$/ { + s/^DEP_FILES = // + :loop + s/\\\\$// + p + n + /\\\\$/ b loop + p + } + /^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`$as_dirname -- "$file" || +$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$file" : 'X\(//\)[^/]' \| \ + X"$file" : 'X\(//\)$' \| \ + X"$file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir=$dirpart/$fdir; as_fn_mkdir_p + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done +done + ;; + + esac +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + diff --git a/sdk/buddy-2.4/autom4te.cache/requests b/sdk/buddy-2.4/autom4te.cache/requests new file mode 100644 index 0000000..796f3f0 --- /dev/null +++ b/sdk/buddy-2.4/autom4te.cache/requests @@ -0,0 +1,79 @@ +# This file was generated by Autom4te Fri Oct 23 20:57:39 UTC 2015. +# It contains the lists of macros which have been traced. +# It can be safely removed. + +@request = ( + bless( [ + '0', + 1, + [ + '/usr/share/autoconf' + ], + [ + '/usr/share/autoconf/autoconf/autoconf.m4f', + 'aclocal.m4', + 'configure.ac' + ], + { + 'm4_sinclude' => 1, + 'AC_CONFIG_SUBDIRS' => 1, + 'AH_OUTPUT' => 1, + 'AC_CANONICAL_BUILD' => 1, + 'include' => 1, + 'AM_PROG_F77_C_O' => 1, + 'AM_PROG_FC_C_O' => 1, + 'AC_FC_PP_SRCEXT' => 1, + 'AC_FC_PP_DEFINE' => 1, + 'LT_SUPPORTED_TAG' => 1, + 'LT_CONFIG_LTDL_DIR' => 1, + 'AC_DEFINE_TRACE_LITERAL' => 1, + '_AM_SUBST_NOTMAKE' => 1, + 'AM_XGETTEXT_OPTION' => 1, + 'AM_MAINTAINER_MODE' => 1, + '_AM_COND_IF' => 1, + 'AC_FC_SRCEXT' => 1, + 'AM_GNU_GETTEXT' => 1, + 'AC_LIBSOURCE' => 1, + 'AM_NLS' => 1, + 'AM_INIT_AUTOMAKE' => 1, + '_AM_COND_ENDIF' => 1, + 'LT_INIT' => 1, + '_LT_AC_TAGCONFIG' => 1, + 'AC_CANONICAL_SYSTEM' => 1, + 'AC_SUBST' => 1, + 'AM_PROG_MOC' => 1, + 'AM_POT_TOOLS' => 1, + '_m4_warn' => 1, + 'AM_CONDITIONAL' => 1, + 'AM_PROG_LIBTOOL' => 1, + '_AM_MAKEFILE_INCLUDE' => 1, + 'm4_pattern_forbid' => 1, + 'AC_SUBST_TRACE' => 1, + '_AM_COND_ELSE' => 1, + 'AC_FC_FREEFORM' => 1, + 'AM_PATH_GUILE' => 1, + 'AC_INIT' => 1, + 'AM_SILENT_RULES' => 1, + 'AM_PROG_AR' => 1, + 'AM_MAKEFILE_INCLUDE' => 1, + 'AC_CANONICAL_TARGET' => 1, + 'm4_pattern_allow' => 1, + 'AC_CONFIG_AUX_DIR' => 1, + 'AC_REQUIRE_AUX_FILE' => 1, + 'AC_CONFIG_HEADERS' => 1, + 'AC_CONFIG_LINKS' => 1, + 'AM_GNU_GETTEXT_INTL_SUBDIR' => 1, + 'AM_AUTOMAKE_VERSION' => 1, + 'AC_CONFIG_LIBOBJ_DIR' => 1, + 'AM_ENABLE_MULTILIB' => 1, + 'AC_CANONICAL_HOST' => 1, + 'AC_CONFIG_FILES' => 1, + 'AC_PROG_LIBTOOL' => 1, + 'AM_PROG_CC_C_O' => 1, + 'AM_PROG_CXX_C_O' => 1, + 'm4_include' => 1, + 'sinclude' => 1 + } + ], 'Autom4te::Request' ) + ); + diff --git a/sdk/buddy-2.4/autom4te.cache/traces.0 b/sdk/buddy-2.4/autom4te.cache/traces.0 new file mode 100644 index 0000000..caf299b --- /dev/null +++ b/sdk/buddy-2.4/autom4te.cache/traces.0 @@ -0,0 +1,712 @@ +m4trace:aclocal.m4:6861: -1- m4_include([m4/debug.m4]) +m4trace:configure.ac:2: -1- AC_INIT([buddy], [2.4]) +m4trace:configure.ac:2: -1- m4_pattern_forbid([^_?A[CHUM]_]) +m4trace:configure.ac:2: -1- m4_pattern_forbid([_AC_]) +m4trace:configure.ac:2: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section `AC_LIBOBJ vs LIBOBJS']) +m4trace:configure.ac:2: -1- m4_pattern_allow([^AS_FLAGS$]) +m4trace:configure.ac:2: -1- m4_pattern_forbid([^_?m4_]) +m4trace:configure.ac:2: -1- m4_pattern_forbid([^dnl$]) +m4trace:configure.ac:2: -1- m4_pattern_forbid([^_?AS_]) +m4trace:configure.ac:2: -1- AC_SUBST([SHELL]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([SHELL]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^SHELL$]) +m4trace:configure.ac:2: -1- AC_SUBST([PATH_SEPARATOR]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PATH_SEPARATOR]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PATH_SEPARATOR$]) +m4trace:configure.ac:2: -1- AC_SUBST([PACKAGE_NAME], [m4_ifdef([AC_PACKAGE_NAME], ['AC_PACKAGE_NAME'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PACKAGE_NAME]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_NAME$]) +m4trace:configure.ac:2: -1- AC_SUBST([PACKAGE_TARNAME], [m4_ifdef([AC_PACKAGE_TARNAME], ['AC_PACKAGE_TARNAME'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PACKAGE_TARNAME]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_TARNAME$]) +m4trace:configure.ac:2: -1- AC_SUBST([PACKAGE_VERSION], [m4_ifdef([AC_PACKAGE_VERSION], ['AC_PACKAGE_VERSION'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PACKAGE_VERSION]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_VERSION$]) +m4trace:configure.ac:2: -1- AC_SUBST([PACKAGE_STRING], [m4_ifdef([AC_PACKAGE_STRING], ['AC_PACKAGE_STRING'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PACKAGE_STRING]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_STRING$]) +m4trace:configure.ac:2: -1- AC_SUBST([PACKAGE_BUGREPORT], [m4_ifdef([AC_PACKAGE_BUGREPORT], ['AC_PACKAGE_BUGREPORT'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PACKAGE_BUGREPORT]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$]) +m4trace:configure.ac:2: -1- AC_SUBST([PACKAGE_URL], [m4_ifdef([AC_PACKAGE_URL], ['AC_PACKAGE_URL'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([PACKAGE_URL]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_URL$]) +m4trace:configure.ac:2: -1- AC_SUBST([exec_prefix], [NONE]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([exec_prefix]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^exec_prefix$]) +m4trace:configure.ac:2: -1- AC_SUBST([prefix], [NONE]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([prefix]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^prefix$]) +m4trace:configure.ac:2: -1- AC_SUBST([program_transform_name], [s,x,x,]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([program_transform_name]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^program_transform_name$]) +m4trace:configure.ac:2: -1- AC_SUBST([bindir], ['${exec_prefix}/bin']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([bindir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^bindir$]) +m4trace:configure.ac:2: -1- AC_SUBST([sbindir], ['${exec_prefix}/sbin']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([sbindir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^sbindir$]) +m4trace:configure.ac:2: -1- AC_SUBST([libexecdir], ['${exec_prefix}/libexec']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([libexecdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^libexecdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([datarootdir], ['${prefix}/share']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([datarootdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^datarootdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([datadir], ['${datarootdir}']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([datadir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^datadir$]) +m4trace:configure.ac:2: -1- AC_SUBST([sysconfdir], ['${prefix}/etc']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([sysconfdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^sysconfdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([sharedstatedir], ['${prefix}/com']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([sharedstatedir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^sharedstatedir$]) +m4trace:configure.ac:2: -1- AC_SUBST([localstatedir], ['${prefix}/var']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([localstatedir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^localstatedir$]) +m4trace:configure.ac:2: -1- AC_SUBST([runstatedir], ['${localstatedir}/run']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([runstatedir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^runstatedir$]) +m4trace:configure.ac:2: -1- AC_SUBST([includedir], ['${prefix}/include']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([includedir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^includedir$]) +m4trace:configure.ac:2: -1- AC_SUBST([oldincludedir], ['/usr/include']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([oldincludedir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^oldincludedir$]) +m4trace:configure.ac:2: -1- AC_SUBST([docdir], [m4_ifset([AC_PACKAGE_TARNAME], + ['${datarootdir}/doc/${PACKAGE_TARNAME}'], + ['${datarootdir}/doc/${PACKAGE}'])]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([docdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^docdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([infodir], ['${datarootdir}/info']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([infodir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^infodir$]) +m4trace:configure.ac:2: -1- AC_SUBST([htmldir], ['${docdir}']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([htmldir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^htmldir$]) +m4trace:configure.ac:2: -1- AC_SUBST([dvidir], ['${docdir}']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([dvidir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^dvidir$]) +m4trace:configure.ac:2: -1- AC_SUBST([pdfdir], ['${docdir}']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([pdfdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^pdfdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([psdir], ['${docdir}']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([psdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^psdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([libdir], ['${exec_prefix}/lib']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([libdir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^libdir$]) +m4trace:configure.ac:2: -1- AC_SUBST([localedir], ['${datarootdir}/locale']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([localedir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^localedir$]) +m4trace:configure.ac:2: -1- AC_SUBST([mandir], ['${datarootdir}/man']) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([mandir]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^mandir$]) +m4trace:configure.ac:2: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_NAME]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_NAME$]) +m4trace:configure.ac:2: -1- AH_OUTPUT([PACKAGE_NAME], [/* Define to the full name of this package. */ +@%:@undef PACKAGE_NAME]) +m4trace:configure.ac:2: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_TARNAME]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_TARNAME$]) +m4trace:configure.ac:2: -1- AH_OUTPUT([PACKAGE_TARNAME], [/* Define to the one symbol short name of this package. */ +@%:@undef PACKAGE_TARNAME]) +m4trace:configure.ac:2: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_VERSION]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_VERSION$]) +m4trace:configure.ac:2: -1- AH_OUTPUT([PACKAGE_VERSION], [/* Define to the version of this package. */ +@%:@undef PACKAGE_VERSION]) +m4trace:configure.ac:2: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_STRING]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_STRING$]) +m4trace:configure.ac:2: -1- AH_OUTPUT([PACKAGE_STRING], [/* Define to the full name and version of this package. */ +@%:@undef PACKAGE_STRING]) +m4trace:configure.ac:2: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_BUGREPORT]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$]) +m4trace:configure.ac:2: -1- AH_OUTPUT([PACKAGE_BUGREPORT], [/* Define to the address where bug reports for this package should be sent. */ +@%:@undef PACKAGE_BUGREPORT]) +m4trace:configure.ac:2: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_URL]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^PACKAGE_URL$]) +m4trace:configure.ac:2: -1- AH_OUTPUT([PACKAGE_URL], [/* Define to the home page for this package. */ +@%:@undef PACKAGE_URL]) +m4trace:configure.ac:2: -1- AC_SUBST([DEFS]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([DEFS]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^DEFS$]) +m4trace:configure.ac:2: -1- AC_SUBST([ECHO_C]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([ECHO_C]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^ECHO_C$]) +m4trace:configure.ac:2: -1- AC_SUBST([ECHO_N]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([ECHO_N]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^ECHO_N$]) +m4trace:configure.ac:2: -1- AC_SUBST([ECHO_T]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([ECHO_T]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^ECHO_T$]) +m4trace:configure.ac:2: -1- AC_SUBST([LIBS]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([LIBS]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^LIBS$]) +m4trace:configure.ac:2: -1- AC_SUBST([build_alias]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([build_alias]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^build_alias$]) +m4trace:configure.ac:2: -1- AC_SUBST([host_alias]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([host_alias]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^host_alias$]) +m4trace:configure.ac:2: -1- AC_SUBST([target_alias]) +m4trace:configure.ac:2: -1- AC_SUBST_TRACE([target_alias]) +m4trace:configure.ac:2: -1- m4_pattern_allow([^target_alias$]) +m4trace:configure.ac:3: -1- AC_CONFIG_AUX_DIR([tools]) +m4trace:configure.ac:4: -1- AM_INIT_AUTOMAKE([foreign nostdinc no-define 1.7.3]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^AM_[A-Z]+FLAGS$]) +m4trace:configure.ac:4: -1- AM_AUTOMAKE_VERSION([1.8.5]) +m4trace:configure.ac:4: -1- AC_REQUIRE_AUX_FILE([install-sh]) +m4trace:configure.ac:4: -1- AC_SUBST([INSTALL_PROGRAM]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([INSTALL_PROGRAM]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^INSTALL_PROGRAM$]) +m4trace:configure.ac:4: -1- AC_SUBST([INSTALL_SCRIPT]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([INSTALL_SCRIPT]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^INSTALL_SCRIPT$]) +m4trace:configure.ac:4: -1- AC_SUBST([INSTALL_DATA]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([INSTALL_DATA]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^INSTALL_DATA$]) +m4trace:configure.ac:4: -1- AC_SUBST([CYGPATH_W]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([CYGPATH_W]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^CYGPATH_W$]) +m4trace:configure.ac:4: -1- _m4_warn([obsolete], [The macro `AC_FOREACH' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:194: AC_FOREACH is expanded from... +aclocal.m4:6749: _AM_SET_OPTIONS is expanded from... +aclocal.m4:6359: AM_INIT_AUTOMAKE is expanded from... +configure.ac:4: the top level]) +m4trace:configure.ac:4: -1- AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME']) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([PACKAGE]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^PACKAGE$]) +m4trace:configure.ac:4: -1- AC_SUBST([VERSION], ['AC_PACKAGE_VERSION']) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([VERSION]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^VERSION$]) +m4trace:configure.ac:4: -1- AC_SUBST([ACLOCAL]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([ACLOCAL]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^ACLOCAL$]) +m4trace:configure.ac:4: -1- AC_SUBST([AUTOCONF]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([AUTOCONF]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^AUTOCONF$]) +m4trace:configure.ac:4: -1- AC_SUBST([AUTOMAKE]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([AUTOMAKE]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^AUTOMAKE$]) +m4trace:configure.ac:4: -1- AC_SUBST([AUTOHEADER]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([AUTOHEADER]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^AUTOHEADER$]) +m4trace:configure.ac:4: -1- AC_SUBST([MAKEINFO]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([MAKEINFO]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^MAKEINFO$]) +m4trace:configure.ac:4: -1- AC_SUBST([AMTAR]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([AMTAR]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^AMTAR$]) +m4trace:configure.ac:4: -1- AC_SUBST([install_sh]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([install_sh]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^install_sh$]) +m4trace:configure.ac:4: -1- AC_SUBST([STRIP]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([STRIP]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^STRIP$]) +m4trace:configure.ac:4: -1- AC_SUBST([INSTALL_STRIP_PROGRAM]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([INSTALL_STRIP_PROGRAM]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^INSTALL_STRIP_PROGRAM$]) +m4trace:configure.ac:4: -1- AC_SUBST([mkdir_p]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([mkdir_p]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^mkdir_p$]) +m4trace:configure.ac:4: -1- AC_SUBST([AWK]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([AWK]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^AWK$]) +m4trace:configure.ac:4: -1- AC_SUBST([SET_MAKE]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([SET_MAKE]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^SET_MAKE$]) +m4trace:configure.ac:4: -1- AC_SUBST([am__leading_dot]) +m4trace:configure.ac:4: -1- AC_SUBST_TRACE([am__leading_dot]) +m4trace:configure.ac:4: -1- m4_pattern_allow([^am__leading_dot$]) +m4trace:configure.ac:8: -1- AC_DEFINE_TRACE_LITERAL([MAJOR_VERSION]) +m4trace:configure.ac:8: -1- m4_pattern_allow([^MAJOR_VERSION$]) +m4trace:configure.ac:8: -1- AH_OUTPUT([MAJOR_VERSION], [/* BuDDy\'s major version. */ +@%:@undef MAJOR_VERSION]) +m4trace:configure.ac:9: -1- AC_DEFINE_TRACE_LITERAL([MINOR_VERSION]) +m4trace:configure.ac:9: -1- m4_pattern_allow([^MINOR_VERSION$]) +m4trace:configure.ac:9: -1- AH_OUTPUT([MINOR_VERSION], [/* BuDDy\'s minor version. */ +@%:@undef MINOR_VERSION]) +m4trace:configure.ac:11: -1- AC_SUBST([CC]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:11: -1- AC_SUBST([CFLAGS]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CFLAGS]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CFLAGS$]) +m4trace:configure.ac:11: -1- AC_SUBST([LDFLAGS]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([LDFLAGS]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^LDFLAGS$]) +m4trace:configure.ac:11: -1- AC_SUBST([LIBS]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([LIBS]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^LIBS$]) +m4trace:configure.ac:11: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:11: -1- AC_SUBST([CC]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:11: -1- AC_SUBST([CC]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:11: -1- AC_SUBST([CC]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:11: -1- AC_SUBST([CC]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:11: -1- AC_SUBST([ac_ct_CC]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([ac_ct_CC]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^ac_ct_CC$]) +m4trace:configure.ac:11: -1- AC_SUBST([EXEEXT], [$ac_cv_exeext]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([EXEEXT]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^EXEEXT$]) +m4trace:configure.ac:11: -1- AC_SUBST([OBJEXT], [$ac_cv_objext]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([OBJEXT]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^OBJEXT$]) +m4trace:configure.ac:11: -1- AC_SUBST([DEPDIR], ["${am__leading_dot}deps"]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([DEPDIR]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^DEPDIR$]) +m4trace:configure.ac:11: -1- AC_SUBST([am__include]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([am__include]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^am__include$]) +m4trace:configure.ac:11: -1- AC_SUBST([am__quote]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([am__quote]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^am__quote$]) +m4trace:configure.ac:11: -1- AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) +m4trace:configure.ac:11: -1- AC_SUBST([AMDEP_TRUE]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([AMDEP_TRUE]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^AMDEP_TRUE$]) +m4trace:configure.ac:11: -1- AC_SUBST([AMDEP_FALSE]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([AMDEP_FALSE]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^AMDEP_FALSE$]) +m4trace:configure.ac:11: -1- AC_SUBST([AMDEPBACKSLASH]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([AMDEPBACKSLASH]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^AMDEPBACKSLASH$]) +m4trace:configure.ac:11: -1- AC_SUBST([CCDEPMODE], [depmode=$am_cv_CC_dependencies_compiler_type]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([CCDEPMODE]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^CCDEPMODE$]) +m4trace:configure.ac:11: -1- AM_CONDITIONAL([am__fastdepCC], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CC_dependencies_compiler_type" = gcc3]) +m4trace:configure.ac:11: -1- AC_SUBST([am__fastdepCC_TRUE]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([am__fastdepCC_TRUE]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^am__fastdepCC_TRUE$]) +m4trace:configure.ac:11: -1- AC_SUBST([am__fastdepCC_FALSE]) +m4trace:configure.ac:11: -1- AC_SUBST_TRACE([am__fastdepCC_FALSE]) +m4trace:configure.ac:11: -1- m4_pattern_allow([^am__fastdepCC_FALSE$]) +m4trace:configure.ac:16: -1- AC_SUBST([CXX]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([CXX]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:16: -1- AC_SUBST([CXXFLAGS]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([CXXFLAGS]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^CXXFLAGS$]) +m4trace:configure.ac:16: -1- AC_SUBST([LDFLAGS]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([LDFLAGS]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^LDFLAGS$]) +m4trace:configure.ac:16: -1- AC_SUBST([LIBS]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([LIBS]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^LIBS$]) +m4trace:configure.ac:16: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:16: -1- AC_SUBST([CXX]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([CXX]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:16: -1- AC_SUBST([ac_ct_CXX]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([ac_ct_CXX]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^ac_ct_CXX$]) +m4trace:configure.ac:16: -1- AC_SUBST([CXXDEPMODE], [depmode=$am_cv_CXX_dependencies_compiler_type]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([CXXDEPMODE]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^CXXDEPMODE$]) +m4trace:configure.ac:16: -1- AM_CONDITIONAL([am__fastdepCXX], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3]) +m4trace:configure.ac:16: -1- AC_SUBST([am__fastdepCXX_TRUE]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([am__fastdepCXX_TRUE]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^am__fastdepCXX_TRUE$]) +m4trace:configure.ac:16: -1- AC_SUBST([am__fastdepCXX_FALSE]) +m4trace:configure.ac:16: -1- AC_SUBST_TRACE([am__fastdepCXX_FALSE]) +m4trace:configure.ac:16: -1- m4_pattern_allow([^am__fastdepCXX_FALSE$]) +m4trace:configure.ac:18: -1- AC_PROG_LIBTOOL +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1473: AC_ARG_ENABLE is expanded from... +aclocal.m4:1749: AC_ENABLE_SHARED is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1473: AC_ARG_ENABLE is expanded from... +aclocal.m4:1788: AC_ENABLE_STATIC is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1473: AC_ARG_ENABLE is expanded from... +aclocal.m4:1827: AC_ENABLE_FAST_INSTALL is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- AC_CANONICAL_HOST +m4trace:configure.ac:18: -1- AC_CANONICAL_BUILD +m4trace:configure.ac:18: -1- AC_REQUIRE_AUX_FILE([config.sub]) +m4trace:configure.ac:18: -1- AC_REQUIRE_AUX_FILE([config.guess]) +m4trace:configure.ac:18: -1- AC_SUBST([build], [$ac_cv_build]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([build]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^build$]) +m4trace:configure.ac:18: -1- AC_SUBST([build_cpu], [$[1]]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([build_cpu]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^build_cpu$]) +m4trace:configure.ac:18: -1- AC_SUBST([build_vendor], [$[2]]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([build_vendor]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^build_vendor$]) +m4trace:configure.ac:18: -1- AC_SUBST([build_os]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([build_os]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^build_os$]) +m4trace:configure.ac:18: -1- AC_SUBST([host], [$ac_cv_host]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([host]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^host$]) +m4trace:configure.ac:18: -1- AC_SUBST([host_cpu], [$[1]]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([host_cpu]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^host_cpu$]) +m4trace:configure.ac:18: -1- AC_SUBST([host_vendor], [$[2]]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([host_vendor]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^host_vendor$]) +m4trace:configure.ac:18: -1- AC_SUBST([host_os]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([host_os]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^host_os$]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1492: AC_ARG_WITH is expanded from... +aclocal.m4:1968: AC_PROG_LD is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- AC_SUBST([GREP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([GREP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^GREP$]) +m4trace:configure.ac:18: -1- AC_SUBST([EGREP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([EGREP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^EGREP$]) +m4trace:configure.ac:18: -1- AC_SUBST([LN_S], [$as_ln_s]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([LN_S]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^LN_S$]) +m4trace:configure.ac:18: -1- AC_SUBST([ECHO]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([ECHO]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^ECHO$]) +m4trace:configure.ac:18: -1- AC_SUBST([AR]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([AR]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^AR$]) +m4trace:configure.ac:18: -1- AC_SUBST([RANLIB]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([RANLIB]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^RANLIB$]) +m4trace:configure.ac:18: -1- AC_SUBST([STRIP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([STRIP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^STRIP$]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1473: AC_ARG_ENABLE is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1492: AC_ARG_WITH is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_CACHE_VAL(lt_prog_compiler_static_works, ...): suspicious cache-id, must contain _cv_ to be cached], [../../lib/autoconf/general.m4:2042: AC_CACHE_VAL is expanded from... +../../lib/autoconf/general.m4:2063: AC_CACHE_CHECK is expanded from... +aclocal.m4:605: AC_LIBTOOL_LINKER_OPTION is expanded from... +aclocal.m4:2471: _LT_AC_LANG_C_CONFIG is expanded from... +aclocal.m4:2470: AC_LIBTOOL_LANG_C_CONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_CACHE_VAL(lt_prog_compiler_pic_works, ...): suspicious cache-id, must contain _cv_ to be cached], [../../lib/autoconf/general.m4:2042: AC_CACHE_VAL is expanded from... +../../lib/autoconf/general.m4:2063: AC_CACHE_CHECK is expanded from... +aclocal.m4:562: AC_LIBTOOL_COMPILER_OPTION is expanded from... +aclocal.m4:4513: AC_LIBTOOL_PROG_COMPILER_PIC is expanded from... +aclocal.m4:2471: _LT_AC_LANG_C_CONFIG is expanded from... +aclocal.m4:2470: AC_LIBTOOL_LANG_C_CONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_TRY_LINK' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:2698: AC_TRY_LINK is expanded from... +../../lib/m4sugar/m4sh.m4:639: AS_IF is expanded from... +../../lib/autoconf/general.m4:2042: AC_CACHE_VAL is expanded from... +../../lib/autoconf/general.m4:2063: AC_CACHE_CHECK is expanded from... +aclocal.m4:427: _LT_AC_LOCK is expanded from... +aclocal.m4:965: AC_LIBTOOL_SYS_HARD_LINK_LOCKS is expanded from... +aclocal.m4:2471: _LT_AC_LANG_C_CONFIG is expanded from... +aclocal.m4:2470: AC_LIBTOOL_LANG_C_CONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body], [../../lib/autoconf/lang.m4:193: AC_LANG_CONFTEST is expanded from... +../../lib/autoconf/general.m4:2672: _AC_LINK_IFELSE is expanded from... +../../lib/autoconf/general.m4:2689: AC_LINK_IFELSE is expanded from... +aclocal.m4:247: _LT_AC_SYS_LIBPATH_AIX is expanded from... +aclocal.m4:4975: AC_LIBTOOL_PROG_LD_SHLIBS is expanded from... +aclocal.m4:2471: _LT_AC_LANG_C_CONFIG is expanded from... +aclocal.m4:2470: AC_LIBTOOL_LANG_C_CONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body], [../../lib/autoconf/lang.m4:193: AC_LANG_CONFTEST is expanded from... +../../lib/autoconf/general.m4:2672: _AC_LINK_IFELSE is expanded from... +../../lib/autoconf/general.m4:2689: AC_LINK_IFELSE is expanded from... +aclocal.m4:247: _LT_AC_SYS_LIBPATH_AIX is expanded from... +aclocal.m4:4975: AC_LIBTOOL_PROG_LD_SHLIBS is expanded from... +aclocal.m4:2471: _LT_AC_LANG_C_CONFIG is expanded from... +aclocal.m4:2470: AC_LIBTOOL_LANG_C_CONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_DLFCN_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_DLFCN_H]) +m4trace:configure.ac:18: -1- AC_SUBST([CPP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([CPP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^CPP$]) +m4trace:configure.ac:18: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:18: -1- AC_SUBST([CPP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([CPP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^CPP$]) +m4trace:configure.ac:18: -1- AC_DEFINE_TRACE_LITERAL([STDC_HEADERS]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^STDC_HEADERS$]) +m4trace:configure.ac:18: -1- AH_OUTPUT([STDC_HEADERS], [/* Define to 1 if you have the ANSI C header files. */ +@%:@undef STDC_HEADERS]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_SYS_TYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_TYPES_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_SYS_STAT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_STAT_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_STDLIB_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDLIB_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_STRING_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STRING_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_MEMORY_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_MEMORY_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_STRINGS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STRINGS_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_INTTYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_INTTYPES_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_STDINT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDINT_H]) +m4trace:configure.ac:18: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTD_H]) +m4trace:configure.ac:18: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DLFCN_H]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^HAVE_DLFCN_H$]) +m4trace:configure.ac:18: -1- _LT_AC_TAGCONFIG +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1492: AC_ARG_WITH is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [back quotes and double quotes must not be escaped in: tag name \"$tagname\" already exists], [aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- AC_SUBST([CXXCPP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([CXXCPP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^CXXCPP$]) +m4trace:configure.ac:18: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:18: -1- AC_SUBST([CXXCPP]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([CXXCPP]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^CXXCPP$]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body], [../../lib/autoconf/lang.m4:193: AC_LANG_CONFTEST is expanded from... +../../lib/autoconf/general.m4:2672: _AC_LINK_IFELSE is expanded from... +../../lib/autoconf/general.m4:2689: AC_LINK_IFELSE is expanded from... +aclocal.m4:247: _LT_AC_SYS_LIBPATH_AIX is expanded from... +aclocal.m4:2612: _LT_AC_LANG_CXX_CONFIG is expanded from... +aclocal.m4:2611: AC_LIBTOOL_LANG_CXX_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body], [../../lib/autoconf/lang.m4:193: AC_LANG_CONFTEST is expanded from... +../../lib/autoconf/general.m4:2672: _AC_LINK_IFELSE is expanded from... +../../lib/autoconf/general.m4:2689: AC_LINK_IFELSE is expanded from... +aclocal.m4:247: _LT_AC_SYS_LIBPATH_AIX is expanded from... +aclocal.m4:2612: _LT_AC_LANG_CXX_CONFIG is expanded from... +aclocal.m4:2611: AC_LIBTOOL_LANG_CXX_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_CACHE_VAL(lt_prog_compiler_pic_works_CXX, ...): suspicious cache-id, must contain _cv_ to be cached], [../../lib/autoconf/general.m4:2042: AC_CACHE_VAL is expanded from... +../../lib/autoconf/general.m4:2063: AC_CACHE_CHECK is expanded from... +aclocal.m4:562: AC_LIBTOOL_COMPILER_OPTION is expanded from... +aclocal.m4:4513: AC_LIBTOOL_PROG_COMPILER_PIC is expanded from... +aclocal.m4:2612: _LT_AC_LANG_CXX_CONFIG is expanded from... +aclocal.m4:2611: AC_LIBTOOL_LANG_CXX_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- AC_SUBST([F77]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([F77]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^F77$]) +m4trace:configure.ac:18: -1- AC_SUBST([FFLAGS]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([FFLAGS]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^FFLAGS$]) +m4trace:configure.ac:18: -1- AC_SUBST([LDFLAGS]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([LDFLAGS]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^LDFLAGS$]) +m4trace:configure.ac:18: -1- AC_SUBST([LIBS]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([LIBS]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^LIBS$]) +m4trace:configure.ac:18: -1- AC_SUBST([F77]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([F77]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^F77$]) +m4trace:configure.ac:18: -1- AC_SUBST([ac_ct_F77]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([ac_ct_F77]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^ac_ct_F77$]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_CACHE_VAL(lt_prog_compiler_pic_works_F77, ...): suspicious cache-id, must contain _cv_ to be cached], [../../lib/autoconf/general.m4:2042: AC_CACHE_VAL is expanded from... +../../lib/autoconf/general.m4:2063: AC_CACHE_CHECK is expanded from... +aclocal.m4:562: AC_LIBTOOL_COMPILER_OPTION is expanded from... +aclocal.m4:4513: AC_LIBTOOL_PROG_COMPILER_PIC is expanded from... +aclocal.m4:3638: _LT_AC_LANG_F77_CONFIG is expanded from... +aclocal.m4:3637: AC_LIBTOOL_LANG_F77_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_LANG_SAVE' is obsolete. +You should run autoupdate.], [../../lib/autoconf/lang.m4:125: AC_LANG_SAVE is expanded from... +aclocal.m4:3738: _LT_AC_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:3737: AC_LIBTOOL_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_CACHE_VAL(lt_prog_compiler_pic_works_GCJ, ...): suspicious cache-id, must contain _cv_ to be cached], [../../lib/autoconf/general.m4:2042: AC_CACHE_VAL is expanded from... +../../lib/autoconf/general.m4:2063: AC_CACHE_CHECK is expanded from... +aclocal.m4:562: AC_LIBTOOL_COMPILER_OPTION is expanded from... +aclocal.m4:4513: AC_LIBTOOL_PROG_COMPILER_PIC is expanded from... +aclocal.m4:3738: _LT_AC_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:3737: AC_LIBTOOL_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body], [../../lib/autoconf/lang.m4:193: AC_LANG_CONFTEST is expanded from... +../../lib/autoconf/general.m4:2672: _AC_LINK_IFELSE is expanded from... +../../lib/autoconf/general.m4:2689: AC_LINK_IFELSE is expanded from... +aclocal.m4:247: _LT_AC_SYS_LIBPATH_AIX is expanded from... +aclocal.m4:4975: AC_LIBTOOL_PROG_LD_SHLIBS is expanded from... +aclocal.m4:3738: _LT_AC_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:3737: AC_LIBTOOL_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([syntax], [AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body], [../../lib/autoconf/lang.m4:193: AC_LANG_CONFTEST is expanded from... +../../lib/autoconf/general.m4:2672: _AC_LINK_IFELSE is expanded from... +../../lib/autoconf/general.m4:2689: AC_LINK_IFELSE is expanded from... +aclocal.m4:247: _LT_AC_SYS_LIBPATH_AIX is expanded from... +aclocal.m4:4975: AC_LIBTOOL_PROG_LD_SHLIBS is expanded from... +aclocal.m4:3738: _LT_AC_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:3737: AC_LIBTOOL_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_LANG_RESTORE' is obsolete. +You should run autoupdate.], [../../lib/autoconf/lang.m4:134: AC_LANG_RESTORE is expanded from... +aclocal.m4:3738: _LT_AC_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:3737: AC_LIBTOOL_LANG_GCJ_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_LANG_SAVE' is obsolete. +You should run autoupdate.], [../../lib/autoconf/lang.m4:125: AC_LANG_SAVE is expanded from... +aclocal.m4:3789: _LT_AC_LANG_RC_CONFIG is expanded from... +aclocal.m4:3788: AC_LIBTOOL_LANG_RC_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- _m4_warn([obsolete], [The macro `AC_LANG_RESTORE' is obsolete. +You should run autoupdate.], [../../lib/autoconf/lang.m4:134: AC_LANG_RESTORE is expanded from... +aclocal.m4:3789: _LT_AC_LANG_RC_CONFIG is expanded from... +aclocal.m4:3788: AC_LIBTOOL_LANG_RC_CONFIG is expanded from... +aclocal.m4:1632: _LT_AC_TAGCONFIG is expanded from... +aclocal.m4:86: AC_LIBTOOL_SETUP is expanded from... +aclocal.m4:66: _AC_PROG_LIBTOOL is expanded from... +aclocal.m4:31: AC_PROG_LIBTOOL is expanded from... +configure.ac:18: the top level]) +m4trace:configure.ac:18: -1- AC_SUBST([LIBTOOL]) +m4trace:configure.ac:18: -1- AC_SUBST_TRACE([LIBTOOL]) +m4trace:configure.ac:18: -1- m4_pattern_allow([^LIBTOOL$]) +m4trace:configure.ac:20: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1473: AC_ARG_ENABLE is expanded from... +m4/debug.m4:1: buddy_DEBUG_FLAGS is expanded from... +configure.ac:20: the top level]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([SWAPCOUNT]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^SWAPCOUNT$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([SWAPCOUNT], [/* Define to 1 to count number of fundamental variable swaps (for debugging). + */ +@%:@undef SWAPCOUNT]) +m4trace:configure.ac:20: -1- _m4_warn([obsolete], [The macro `AC_HELP_STRING' is obsolete. +You should run autoupdate.], [../../lib/autoconf/general.m4:207: AC_HELP_STRING is expanded from... +../../lib/autoconf/general.m4:1473: AC_ARG_ENABLE is expanded from... +m4/debug.m4:1: buddy_DEBUG_FLAGS is expanded from... +configure.ac:20: the top level]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([CACHESTATS]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^CACHESTATS$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([CACHESTATS], [/* Defube to 1 to gather statistical information about operator and unique + node caching (for debugging). */ +@%:@undef CACHESTATS]) +m4trace:configure.ac:22: -1- AC_CONFIG_HEADERS([config.h]) +m4trace:configure.ac:24: -1- AC_CONFIG_FILES([ + Makefile + src/Makefile +]) +m4trace:configure.ac:29: -1- AC_SUBST([LIB@&t@OBJS], [$ac_libobjs]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([LIB@&t@OBJS]) +m4trace:configure.ac:29: -1- m4_pattern_allow([^LIB@&t@OBJS$]) +m4trace:configure.ac:29: -1- AC_SUBST([LTLIBOBJS], [$ac_ltlibobjs]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([LTLIBOBJS]) +m4trace:configure.ac:29: -1- m4_pattern_allow([^LTLIBOBJS$]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([top_builddir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([top_build_prefix]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([srcdir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([abs_srcdir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([top_srcdir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([abs_top_srcdir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([builddir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([abs_builddir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([abs_top_builddir]) +m4trace:configure.ac:29: -1- AC_SUBST_TRACE([INSTALL]) diff --git a/sdk/buddy-2.4/config.h.in b/sdk/buddy-2.4/config.h.in new file mode 100644 index 0000000..78ed6d7 --- /dev/null +++ b/sdk/buddy-2.4/config.h.in @@ -0,0 +1,66 @@ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Defube to 1 to gather statistical information about operator and unique + node caching (for debugging). */ +#undef CACHESTATS + +/* Define to 1 if you have the header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* BuDDy's major version. */ +#undef MAJOR_VERSION + +/* BuDDy's minor version. */ +#undef MINOR_VERSION + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#undef PACKAGE_URL + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Define to 1 to count number of fundamental variable swaps (for debugging). + */ +#undef SWAPCOUNT diff --git a/sdk/buddy-2.4/configure b/sdk/buddy-2.4/configure new file mode 100644 index 0000000..5ff78bc --- /dev/null +++ b/sdk/buddy-2.4/configure @@ -0,0 +1,19914 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.69 for buddy 2.4. +# +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, +$0: including any error possibly output before this +$0: message. Then install a modern shell, or manually run +$0: the script under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + + +# Check that we are running under the correct shell. +SHELL=${CONFIG_SHELL-/bin/sh} + +case X$ECHO in +X*--fallback-echo) + # Remove one level of quotation (which was required for Make). + ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','` + ;; +esac + +echo=${ECHO-echo} +if test "X$1" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift +elif test "X$1" = X--fallback-echo; then + # Avoid inline document here, it may be left over + : +elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then + # Yippee, $echo works! + : +else + # Restart under the correct shell. + exec $SHELL "$0" --no-reexec ${1+"$@"} +fi + +if test "X$1" = X--fallback-echo; then + # used as fallback echo + shift + cat </dev/null && + echo_test_string="`eval $cmd`" && + (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null + then + break + fi + done +fi + +if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + : +else + # The Solaris, AIX, and Digital Unix default echo programs unquote + # backslashes. This makes it impossible to quote backslashes using + # echo "$something" | sed 's/\\/\\\\/g' + # + # So, first we look for a working echo in the user's PATH. + + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for dir in $PATH /usr/ucb; do + IFS="$lt_save_ifs" + if (test -f $dir/echo || test -f $dir/echo$ac_exeext) && + test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + echo="$dir/echo" + break + fi + done + IFS="$lt_save_ifs" + + if test "X$echo" = Xecho; then + # We didn't find a better echo, so look for alternatives. + if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + # This shell has a builtin print -r that does the trick. + echo='print -r' + elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) && + test "X$CONFIG_SHELL" != X/bin/ksh; then + # If we have ksh, try running configure again with it. + ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} + export ORIGINAL_CONFIG_SHELL + CONFIG_SHELL=/bin/ksh + export CONFIG_SHELL + exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"} + else + # Try using printf. + echo='printf %s\n' + if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && + echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + # Cool, printf works + : + elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` && + test "X$echo_testing_string" = 'X\t' && + echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL + export CONFIG_SHELL + SHELL="$CONFIG_SHELL" + export SHELL + echo="$CONFIG_SHELL $0 --fallback-echo" + elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` && + test "X$echo_testing_string" = 'X\t' && + echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` && + test "X$echo_testing_string" = "X$echo_test_string"; then + echo="$CONFIG_SHELL $0 --fallback-echo" + else + # maybe with a smaller string... + prev=: + + for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do + if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null + then + break + fi + prev="$cmd" + done + + if test "$prev" != 'sed 50q "$0"'; then + echo_test_string=`eval $prev` + export echo_test_string + exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"} + else + # Oops. We lost completely, so just stick with echo. + echo=echo + fi + fi + fi + fi +fi +fi + +# Copy echo and quote the copy suitably for passing to libtool from +# the Makefile, instead of quoting the original, which is used later. +ECHO=$echo +if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then + ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo" +fi + + + + +tagnames=${tagnames+${tagnames},}CXX + +tagnames=${tagnames+${tagnames},}F77 + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='buddy' +PACKAGE_TARNAME='buddy' +PACKAGE_VERSION='2.4' +PACKAGE_STRING='buddy 2.4' +PACKAGE_BUGREPORT='' +PACKAGE_URL='' + +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='LTLIBOBJS +LIBOBJS +LIBTOOL +ac_ct_F77 +FFLAGS +F77 +CXXCPP +CPP +RANLIB +AR +ECHO +LN_S +EGREP +GREP +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +am__fastdepCXX_FALSE +am__fastdepCXX_TRUE +CXXDEPMODE +ac_ct_CXX +CXXFLAGS +CXX +am__fastdepCC_FALSE +am__fastdepCC_TRUE +CCDEPMODE +AMDEPBACKSLASH +AMDEP_FALSE +AMDEP_TRUE +am__quote +am__include +DEPDIR +OBJEXT +EXEEXT +ac_ct_CC +CPPFLAGS +LDFLAGS +CFLAGS +CC +am__leading_dot +SET_MAKE +AWK +mkdir_p +INSTALL_STRIP_PROGRAM +STRIP +install_sh +AMTAR +MAKEINFO +AUTOHEADER +AUTOMAKE +AUTOCONF +ACLOCAL +VERSION +PACKAGE +CYGPATH_W +INSTALL_DATA +INSTALL_SCRIPT +INSTALL_PROGRAM +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +runstatedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +enable_dependency_tracking +enable_shared +enable_static +enable_fast_install +with_gnu_ld +enable_libtool_lock +with_pic +with_tags +enable_swap_count +enable_cache_stats +' + ac_precious_vars='build_alias +host_alias +target_alias +CC +CFLAGS +LDFLAGS +LIBS +CPPFLAGS +CXX +CXXFLAGS +CCC +CPP +CXXCPP +F77 +FFLAGS' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +runstatedir='${localstatedir}/run' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -runstatedir | --runstatedir | --runstatedi | --runstated \ + | --runstate | --runstat | --runsta | --runst | --runs \ + | --run | --ru | --r) + ac_prev=runstatedir ;; + -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ + | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ + | --run=* | --ru=* | --r=*) + runstatedir=$ac_optarg ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir runstatedir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures buddy 2.4 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/buddy] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +Program names: + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM run sed PROGRAM on installed program names + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of buddy 2.4:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --disable-dependency-tracking speeds up one-time build + --enable-dependency-tracking do not reject slow dependency extractors + --enable-shared[=PKGS] build shared libraries [default=yes] + --enable-static[=PKGS] build static libraries [default=yes] + --enable-fast-install[=PKGS] + optimize for fast installation [default=yes] + --disable-libtool-lock avoid locking (might break parallel builds) + --enable-swap-count Count number of fundamental variable swaps (for + debugging) + --enable-cache-stats Gather statistical information about operator and + unique node caching (for debugging) + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-gnu-ld assume the C compiler uses GNU ld [default=no] + --with-pic try to use only PIC/non-PIC objects [default=use + both] + --with-tags[=TAGS] include additional configurations [automatic] + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CXX C++ compiler command + CXXFLAGS C++ compiler flags + CPP C preprocessor + CXXCPP C++ preprocessor + F77 Fortran 77 compiler command + FFLAGS Fortran 77 compiler flags + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to the package provider. +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +buddy configure 2.4 +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +# ac_fn_c_try_compile LINENO +# -------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_compile + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_c_try_link LINENO +# ----------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_link + +# ac_fn_c_try_cpp LINENO +# ---------------------- +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_cpp + +# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists, giving a warning if it cannot be compiled using +# the include files in INCLUDES and setting the cache variable VAR +# accordingly. +ac_fn_c_check_header_mongrel () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if eval \${$3+:} false; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +else + # Is the header compilable? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 +$as_echo_n "checking $2 usability... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_header_compiler=yes +else + ac_header_compiler=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 +$as_echo "$ac_header_compiler" >&6; } + +# Is the header present? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 +$as_echo_n "checking $2 presence... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include <$2> +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + ac_header_preproc=yes +else + ac_header_preproc=no +fi +rm -f conftest.err conftest.i conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 +$as_echo "$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( + yes:no: ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 +$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; + no:yes:* ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 +$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 +$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 +$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 +$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=\$ac_header_compiler" +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_mongrel + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes +# that executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run + +# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists and can be compiled using the include files in +# INCLUDES, setting the cache variable VAR accordingly. +ac_fn_c_check_header_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_compile + +# ac_fn_c_check_func LINENO FUNC VAR +# ---------------------------------- +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_func + +# ac_fn_cxx_try_cpp LINENO +# ------------------------ +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_cpp + +# ac_fn_cxx_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_link + +# ac_fn_cxx_check_func LINENO FUNC VAR +# ------------------------------------ +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_cxx_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_cxx_check_func + +# ac_fn_f77_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_f77_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_f77_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_f77_try_compile + +# ac_fn_f77_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_f77_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_f77_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_f77_try_link +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by buddy $as_me 2.4, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_aux_dir= +for ac_dir in tools "$srcdir"/tools; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in tools \"$srcdir\"/tools" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + +am__api_version="1.8" +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +# Reject install programs that cannot install multiple files. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +$as_echo_n "checking for a BSD-compatible install... " >&6; } +if test -z "$INSTALL"; then +if ${ac_cv_path_install+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + # Account for people who put trailing slashes in PATH elements. +case $as_dir/ in #(( + ./ | .// | /[cC]/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ + /usr/ucb/* ) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + rm -rf conftest.one conftest.two conftest.dir + echo one > conftest.one + echo two > conftest.two + mkdir conftest.dir + if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && + test -s conftest.one && test -s conftest.two && + test -s conftest.dir/conftest.one && + test -s conftest.dir/conftest.two + then + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + fi + done + done + ;; +esac + + done +IFS=$as_save_IFS + +rm -rf conftest.one conftest.two conftest.dir + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. Don't cache a + # value for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + INSTALL=$ac_install_sh + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +$as_echo "$INSTALL" >&6; } + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 +$as_echo_n "checking whether build environment is sane... " >&6; } +# Just in case +sleep 1 +echo timestamp > conftest.file +# Do `set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null` + if test "$*" = "X"; then + # -L didn't work. + set X `ls -t $srcdir/configure conftest.file` + fi + rm -f conftest.file + if test "$*" != "X $srcdir/configure conftest.file" \ + && test "$*" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + as_fn_error $? "ls -t appears to fail. Make sure there is not a broken +alias in your environment" "$LINENO" 5 + fi + + test "$2" = conftest.file + ) +then + # Ok. + : +else + as_fn_error $? "newly created file is older than distributed files! +Check your system clock" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +test "$program_prefix" != NONE && + program_transform_name="s&^&$program_prefix&;$program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s&\$&$program_suffix&;$program_transform_name" +# Double any \ or $. +# By default was `s,x,x', remove it if useless. +ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' +program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` + +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` + +test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing" +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5 +$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;} +fi + +if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then + # Keeping the `.' argument allows $(mkdir_p) to be used without + # argument. Indeed, we sometimes output rules like + # $(mkdir_p) $(somedir) + # where $(somedir) is conditionally defined. + # (`test -n '$(somedir)' && $(mkdir_p) $(somedir)' is a more + # expensive solution, as it forces Make to start a sub-shell.) + mkdir_p='mkdir -p -- .' +else + # On NextStep and OpenStep, the `mkdir' command does not + # recognize any option. It will interpret all options as + # directories to create, and then abort because `.' already + # exists. + for d in ./-p ./--version; + do + test -d $d && rmdir $d + done + # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists. + if test -f "$ac_aux_dir/mkinstalldirs"; then + mkdir_p='$(mkinstalldirs)' + else + mkdir_p='$(install_sh) -d' + fi +fi + +for ac_prog in gawk mawk nawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AWK+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AWK="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } +set x ${MAKE-make} +ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat >conftest.make <<\_ACEOF +SHELL = /bin/sh +all: + @echo '@@@%%%=$(MAKE)=@@@%%%' +_ACEOF +# GNU make sometimes prints "make[1]: Entering ...", which would confuse us. +case `${MAKE-make} -f conftest.make 2>/dev/null` in + *@@@%%%=?*=@@@%%%*) + eval ac_cv_prog_make_${ac_make}_set=yes;; + *) + eval ac_cv_prog_make_${ac_make}_set=no;; +esac +rm -f conftest.make +fi +if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + SET_MAKE= +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + SET_MAKE="MAKE=${MAKE-make}" +fi + +rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null + +# test to see if srcdir already configured +if test "`cd $srcdir && pwd`" != "`pwd`" && + test -f $srcdir/config.status; then + as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi + + +# Define the identity of the package. + PACKAGE='buddy' + VERSION='2.4' + + +# Some tools Automake needs. + +ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} + + +AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} + + +AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} + + +AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} + + +MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} + + +AMTAR=${AMTAR-"${am_missing_run}tar"} + +install_sh=${install_sh-"$am_aux_dir/install-sh"} + +# Installed binaries are usually stripped using `strip' when the user +# run `make install-strip'. However `strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the `STRIP' environment variable to overrule this program. +if test "$cross_compiling" != no; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +fi +INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s" + +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. + + + + +MAJOR_VERSION=`echo "$VERSION" | sed -e 's/^\([0-9]*\)\.[0-9]*.*$/\1/'` +MINOR_VERSION=`echo "$VERSION" | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'` + +cat >>confdefs.h <<_ACEOF +#define MAJOR_VERSION $MAJOR_VERSION +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define MINOR_VERSION $MINOR_VERSION +_ACEOF + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl.exe + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl.exe +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See \`config.log' for more details" "$LINENO" 5; } + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +$as_echo_n "checking whether the C compiler works... " >&6; } +ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "C compiler cannot create executables +See \`config.log' for more details" "$LINENO" 5; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +$as_echo_n "checking for C compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$ac_file" >&6; } +ac_exeext=$ac_cv_exeext + +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +ac_clean_files="$ac_clean_files conftest.out" +# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if ${ac_cv_objext+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of object files: cannot compile +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if ${ac_cv_c_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if ${ac_cv_prog_cc_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +DEPDIR="${am__leading_dot}deps" + +ac_config_commands="$ac_config_commands depfiles" + + +am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo done +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 +$as_echo_n "checking for style of include used by $am_make... " >&6; } +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# We grep out `Entering directory' and `Leaving directory' +# messages which can occur if `w' ends up in MAKEFLAGS. +# In particular we don't look at `^make:' because GNU make might +# be invoked under some other name (usually "gmake"), in which +# case it prints its new name instead of `make'. +if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then + am__include=include + am__quote= + _am_result=GNU +fi +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then + am__include=.include + am__quote="\"" + _am_result=BSD + fi +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 +$as_echo "$_am_result" >&6; } +rm -f confinc confmf + +# Check whether --enable-dependency-tracking was given. +if test "${enable_dependency_tracking+set}" = set; then : + enableval=$enable_dependency_tracking; +fi + +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' +fi + + +if test "x$enable_dependency_tracking" != xno; then + AMDEP_TRUE= + AMDEP_FALSE='#' +else + AMDEP_TRUE='#' + AMDEP_FALSE= +fi + + + + +depcc="$CC" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CC_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named `D' -- because `-MD' means `put the output + # in D'. + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CC_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with + # Solaris 8's {/usr,}/bin/sh. + touch sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + case $depmode in + nosideeffect) + # after this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + none) break ;; + esac + # We check with `-c' and `-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle `-M -o', and we need to detect this. + if depmode=$depmode \ + source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CC_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CC_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } +CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type + + + +if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then + am__fastdepCC_TRUE= + am__fastdepCC_FALSE='#' +else + am__fastdepCC_TRUE='#' + am__fastdepCC_FALSE= +fi + + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CXX="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if ${ac_cv_cxx_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if ${ac_cv_prog_cxx_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CXX" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CXX_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named `D' -- because `-MD' means `put the output + # in D'. + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CXX_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with + # Solaris 8's {/usr,}/bin/sh. + touch sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + case $depmode in + nosideeffect) + # after this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + none) break ;; + esac + # We check with `-c' and `-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle `-M -o', and we need to detect this. + if depmode=$depmode \ + source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CXX_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CXX_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } +CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type + + + +if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then + am__fastdepCXX_TRUE= + am__fastdepCXX_FALSE='#' +else + am__fastdepCXX_TRUE='#' + am__fastdepCXX_FALSE= +fi + + + +# Check whether --enable-shared was given. +if test "${enable_shared+set}" = set; then : + enableval=$enable_shared; p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_shared=yes +fi + + +# Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_static=yes +fi + + +# Check whether --enable-fast-install was given. +if test "${enable_fast_install+set}" = set; then : + enableval=$enable_fast_install; p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_fast_install=yes +fi + + +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if ${ac_cv_build+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if ${ac_cv_host+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +$as_echo_n "checking for a sed that does not truncate output... " >&6; } +if ${lt_cv_path_SED+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Loop through the user's path and test for sed and gsed. +# Then use that list of sed's as ones to test for truncation. +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for lt_ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then + lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" + fi + done + done +done +lt_ac_max=0 +lt_ac_count=0 +# Add /usr/xpg4/bin/sed as it is typically found on Solaris +# along with /bin/sed that truncates output. +for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do + test ! -f $lt_ac_sed && break + cat /dev/null > conftest.in + lt_ac_count=0 + echo $ECHO_N "0123456789$ECHO_C" >conftest.in + # Check for GNU sed and select it if it is found. + if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then + lt_cv_path_SED=$lt_ac_sed + break + fi + while true; do + cat conftest.in conftest.in >conftest.tmp + mv conftest.tmp conftest.in + cp conftest.in conftest.nl + echo >>conftest.nl + $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break + cmp -s conftest.out conftest.nl || break + # 10000 chars as input seems more than enough + test $lt_ac_count -gt 10 && break + lt_ac_count=`expr $lt_ac_count + 1` + if test $lt_ac_count -gt $lt_ac_max; then + lt_ac_max=$lt_ac_count + lt_cv_path_SED=$lt_ac_sed + fi + done +done +SED=$lt_cv_path_SED + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 +$as_echo "$SED" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if ${ac_cv_path_GREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if ${ac_cv_path_EGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'EGREP' >> "conftest.nl" + "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'` + while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do + ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some GNU ld's only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU ld's only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +$as_echo_n "checking for $LD option to reload object files... " >&6; } +if ${lt_cv_ld_reload_flag+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_reload_flag='-r' +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +$as_echo "$lt_cv_ld_reload_flag" >&6; } +reload_flag=$lt_cv_ld_reload_flag +case $reload_flag in +"" | " "*) ;; +*) reload_flag=" $reload_flag" ;; +esac +reload_cmds='$LD$reload_flag -o $output$reload_objs' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD-compatible nm" >&5 +$as_echo_n "checking for BSD-compatible nm... " >&6; } +if ${lt_cv_path_NM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/${ac_tool_prefix}nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + esac + fi + done + IFS="$lt_save_ifs" + test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +$as_echo "$lt_cv_path_NM" >&6; } +NM="$lt_cv_path_NM" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +$as_echo_n "checking whether ln -s works... " >&6; } +LN_S=$as_ln_s +if test "$LN_S" = "ln -s"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +$as_echo "no, using $LN_S" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognise dependent libraries" >&5 +$as_echo_n "checking how to recognise dependent libraries... " >&6; } +if ${lt_cv_deplibs_check_method+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_deplibs_check_method='unknown' +# Need to set the preceding variable on all platforms that support +# interlibrary dependencies. +# 'none' -- dependencies not supported. +# `unknown' -- same as none, but documents that we really don't know. +# 'pass_all' -- all dependencies passed with no checks. +# 'test_compile' -- check by making test program. +# 'file_magic [[regex]]' -- check by looking for files in library path +# which responds to the $file_magic_cmd with a given extended regex. +# If you have `file' or equivalent on your system and you're not sure +# whether `pass_all' will *always* work, you probably want this one. + +case $host_os in +aix4* | aix5*) + lt_cv_deplibs_check_method=pass_all + ;; + +beos*) + lt_cv_deplibs_check_method=pass_all + ;; + +bsdi4*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' + lt_cv_file_magic_cmd='/usr/bin/file -L' + lt_cv_file_magic_test_file=/shlib/libc.so + ;; + +cygwin*) + # func_win32_libid is a shell function defined in ltmain.sh + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + ;; + +mingw* | pw32*) + # Base MSYS/MinGW do not provide the 'file' command needed by + # func_win32_libid shell function, so use a weaker test based on 'objdump'. + lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | kfreebsd*-gnu) + if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case "$host_cpu" in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]' + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be Linux ELF. +linux*) + case $host_cpu in + alpha*|hppa*|i*86|ia64*|m68*|mips*|powerpc*|sparc*|s390*|sh*|x86_64*) + lt_cv_deplibs_check_method=pass_all ;; + *) + # glibc up to 2.1.1 does not perform some relocations on ARM + # this will be overridden with pass_all, but let us keep it just in case + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;; + esac + lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so` + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +nto-qnx*) + lt_cv_deplibs_check_method=unknown + ;; + +openbsd*) + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object' + else + lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +sco3.2v5*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +$as_echo "$lt_cv_deplibs_check_method" >&6; } +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '#line 5144 "configure"' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + lt_cv_cc_lib64_suffix=no + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case "`/usr/bin/file conftest.$ac_objext`" in + *32-bit*) + case $host in + x86_64-*linux*) + LD="${LD-ld} -m elf_i386" + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + lt_cv_cc_lib64_suffix=yes + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + lt_cv_cc_lib64_suffix=yes + ;; + s390*-*linux*) + LD="${LD-ld} -m elf64_s390" + lt_cv_cc_lib64_suffix=yes + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + lt_cv_cc_lib64_suffix=yes + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 +$as_echo_n "checking whether the C compiler needs -belf... " >&6; } +if ${lt_cv_cc_needs_belf+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_cc_needs_belf=yes +else + lt_cv_cc_needs_belf=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +$as_echo "$lt_cv_cc_needs_belf" >&6; } + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; + +esac + +need_locks="$enable_libtool_lock" + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in dlfcn.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default" +if test "x$ac_cv_header_dlfcn_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_DLFCN_H 1 +_ACEOF + +fi + +done + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +$as_echo_n "checking how to run the C++ preprocessor... " >&6; } +if test -z "$CXXCPP"; then + if ${ac_cv_prog_CXXCPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CXXCPP=$CXXCPP + +fi + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +$as_echo "$CXXCPP" >&6; } +ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +ac_ext=f +ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5' +ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_f77_compiler_gnu +if test -n "$ac_tool_prefix"; then + for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$F77"; then + ac_cv_prog_F77="$F77" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_F77="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +F77=$ac_cv_prog_F77 +if test -n "$F77"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $F77" >&5 +$as_echo "$F77" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$F77" && break + done +fi +if test -z "$F77"; then + ac_ct_F77=$F77 + for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_F77"; then + ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_F77="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_F77=$ac_cv_prog_ac_ct_F77 +if test -n "$ac_ct_F77"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_F77" >&5 +$as_echo "$ac_ct_F77" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_F77" && break +done + + if test "x$ac_ct_F77" = x; then + F77="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + F77=$ac_ct_F77 + fi +fi + + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran 77 compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done +rm -f a.out + +# If we don't use `.F' as extension, the preprocessor is not run on the +# input file. (Note that this only needs to work for GNU compilers.) +ac_save_ext=$ac_ext +ac_ext=F +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran 77 compiler" >&5 +$as_echo_n "checking whether we are using the GNU Fortran 77 compiler... " >&6; } +if ${ac_cv_f77_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat > conftest.$ac_ext <<_ACEOF + program main +#ifndef __GNUC__ + choke me +#endif + + end +_ACEOF +if ac_fn_f77_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_f77_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_f77_compiler_gnu" >&5 +$as_echo "$ac_cv_f77_compiler_gnu" >&6; } +ac_ext=$ac_save_ext +ac_test_FFLAGS=${FFLAGS+set} +ac_save_FFLAGS=$FFLAGS +FFLAGS= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $F77 accepts -g" >&5 +$as_echo_n "checking whether $F77 accepts -g... " >&6; } +if ${ac_cv_prog_f77_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + FFLAGS=-g +cat > conftest.$ac_ext <<_ACEOF + program main + + end +_ACEOF +if ac_fn_f77_try_compile "$LINENO"; then : + ac_cv_prog_f77_g=yes +else + ac_cv_prog_f77_g=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_f77_g" >&5 +$as_echo "$ac_cv_prog_f77_g" >&6; } +if test "$ac_test_FFLAGS" = set; then + FFLAGS=$ac_save_FFLAGS +elif test $ac_cv_prog_f77_g = yes; then + if test "x$ac_cv_f77_compiler_gnu" = xyes; then + FFLAGS="-g -O2" + else + FFLAGS="-g" + fi +else + if test "x$ac_cv_f77_compiler_gnu" = xyes; then + FFLAGS="-O2" + else + FFLAGS= + fi +fi + +if test $ac_compiler_gnu = yes; then + G77=yes +else + G77= +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + +# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers! + +# find the maximum length of command line arguments +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +$as_echo_n "checking the maximum length of command line arguments... " >&6; } +if ${lt_cv_sys_max_cmd_len+:} false; then : + $as_echo_n "(cached) " >&6 +else + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + *) + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while (test "X"`$CONFIG_SHELL $0 --fallback-echo "X$teststring" 2>/dev/null` \ + = "XX$teststring") >/dev/null 2>&1 && + new_result=`expr "X$teststring" : ".*" 2>&1` && + lt_cv_sys_max_cmd_len=$new_result && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + teststring= + # Add a significant safety factor because C++ compilers can tack on massive + # amounts of additional arguments before passing them to the linker. + # It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + ;; + esac + +fi + +if test -n $lt_cv_sys_max_cmd_len ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +$as_echo "$lt_cv_sys_max_cmd_len" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 +$as_echo "none" >&6; } +fi + + + + +# Check for command to grab the raw symbol name followed by C symbol from nm. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; } +if ${lt_cv_sys_global_symbol_pipe+:} false; then : + $as_echo_n "(cached) " >&6 +else + +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[BCDEGRST]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([_A-Za-z][_A-Za-z0-9]*\)' + +# Transform the above into a raw symbol and a C symbol. +symxfrm='\1 \2\3 \3' + +# Transform an extracted symbol line into a proper C declaration +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[BCDT]' + ;; +cygwin* | mingw* | pw32*) + symcode='[ABCDGISTW]' + ;; +hpux*) # Its linker distinguishes data from code symbols + if test "$host_cpu" = ia64; then + symcode='[ABCDEGRST]' + fi + lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" + ;; +irix* | nonstopux*) + symcode='[BCDEGRST]' + ;; +osf*) + symcode='[BCDEGQRST]' + ;; +solaris* | sysv5*) + symcode='[BDRT]' + ;; +sysv4) + symcode='[DFNSTU]' + ;; +esac + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[ABCDGIRSTW]' ;; +esac + +# Try without a prefix undercore, then with it. +for ac_symprfx in "" "_"; do + + # Write the raw and C identifiers. + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Now try to grab the symbols. + nlist=conftest.nm + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\""; } >&5 + (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if grep ' nm_test_var$' "$nlist" >/dev/null; then + if grep ' nm_test_func$' "$nlist" >/dev/null; then + cat < conftest.$ac_ext +#ifdef __cplusplus +extern "C" { +#endif + +EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | grep -v main >> conftest.$ac_ext' + + cat <> conftest.$ac_ext +#if defined (__STDC__) && __STDC__ +# define lt_ptr_t void * +#else +# define lt_ptr_t char * +# define const +#endif + +/* The mapping between symbol names and symbols. */ +const struct { + const char *name; + lt_ptr_t address; +} +lt_preloaded_symbols[] = +{ +EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | grep -v main >> conftest.$ac_ext + cat <<\EOF >> conftest.$ac_ext + {0, (lt_ptr_t) 0} +}; + +#ifdef __cplusplus +} +#endif +EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_save_LIBS="$LIBS" + lt_save_CFLAGS="$CFLAGS" + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS="$lt_save_LIBS" + CFLAGS="$lt_save_CFLAGS" + else + echo "cannot find nm_test_func in $nlist" >&5 + fi + else + echo "cannot find nm_test_var in $nlist" >&5 + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 + fi + else + echo "$progname: failed program was:" >&5 + cat conftest.$ac_ext >&5 + fi + rm -f conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done + +fi + +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +$as_echo "failed" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +$as_echo_n "checking for objdir... " >&6; } +if ${lt_cv_objdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +$as_echo "$lt_cv_objdir" >&6; } +objdir=$lt_cv_objdir + + + + + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed='sed -e s/^X//' +sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' + +# Constants: +rm="rm -f" + +# Global variables: +default_ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except M$VC, +# which needs '.lib'). +libext=a +ltmain="$ac_aux_dir/ltmain.sh" +ofile="$default_ofile" +with_gnu_ld="$lt_cv_prog_gnu_ld" + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. +set dummy ${ac_tool_prefix}ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="${ac_tool_prefix}ar" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_AR"; then + ac_ct_AR=$AR + # Extract the first word of "ar", so it can be a program name with args. +set dummy ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="ar" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +else + AR="$ac_cv_prog_AR" +fi + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RANLIB=$ac_cv_prog_RANLIB +if test -n "$RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +$as_echo "$RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_RANLIB"; then + ac_ct_RANLIB=$RANLIB + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_RANLIB"; then + ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_RANLIB="ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB +if test -n "$ac_ct_RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +$as_echo "$ac_ct_RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_RANLIB" = x; then + RANLIB=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + RANLIB=$ac_ct_RANLIB + fi +else + RANLIB="$ac_cv_prog_RANLIB" +fi + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$AR" && AR=ar +test -z "$AR_FLAGS" && AR_FLAGS=cru +test -z "$AS" && AS=as +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$DLLTOOL" && DLLTOOL=dlltool +test -z "$LD" && LD=ld +test -z "$LN_S" && LN_S="ln -s" +test -z "$MAGIC_CMD" && MAGIC_CMD=file +test -z "$NM" && NM=nm +test -z "$SED" && SED=sed +test -z "$OBJDUMP" && OBJDUMP=objdump +test -z "$RANLIB" && RANLIB=: +test -z "$STRIP" && STRIP=: +test -z "$ac_objext" && ac_objext=o + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds" + ;; + *) + old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib" +fi + +# Only perform the check for file, if the check method requires it +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 +$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/${ac_tool_prefix}file; then + lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5 +$as_echo_n "checking for file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/file; then + lt_cv_path_MAGIC_CMD="$ac_dir/file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + else + MAGIC_CMD=: + fi +fi + + fi + ;; +esac + +enable_dlopen=no +enable_win32_dll=no + +# Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + + +# Check whether --with-pic was given. +if test "${with_pic+set}" = set; then : + withval=$with_pic; pic_mode="$withval" +else + pic_mode=default +fi + +test -z "$pic_mode" && pic_mode=default + +# Use C for the default configuration in the libtool script +tagname= +lt_save_CC="$CC" +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +objext=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}\n' + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# +# Check for any special shared library compilation flags. +# +lt_prog_cc_shlib= +if test "$GCC" = no; then + case $host_os in + sco3.2v5*) + lt_prog_cc_shlib='-belf' + ;; + esac +fi +if test -n "$lt_prog_cc_shlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' requires \`$lt_prog_cc_shlib' to build shared libraries" >&5 +$as_echo "$as_me: WARNING: \`$CC' requires \`$lt_prog_cc_shlib' to build shared libraries" >&2;} + if echo "$old_CC $old_CFLAGS " | grep "[ ]$lt_prog_cc_shlib[ ]" >/dev/null; then : + else + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: add \`$lt_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&5 +$as_echo "$as_me: WARNING: add \`$lt_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&2;} + lt_cv_prog_cc_can_build_shared=no + fi +fi + + +# +# Check to make sure the static flag actually works. +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_prog_compiler_static works" >&5 +$as_echo_n "checking if $compiler static flag $lt_prog_compiler_static works... " >&6; } +if ${lt_prog_compiler_static_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_static_works=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_prog_compiler_static" + printf "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + else + lt_prog_compiler_static_works=yes + fi + fi + $rm conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_static_works" >&5 +$as_echo "$lt_prog_compiler_static_works" >&6; } + +if test x"$lt_prog_compiler_static_works" = xyes; then + : +else + lt_prog_compiler_static= +fi + + + + +lt_prog_compiler_no_builtin_flag= + +if test "$GCC" = yes; then + lt_prog_compiler_no_builtin_flag=' -fno-builtin' + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:6833: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:6837: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" +else + : +fi + +fi + +lt_prog_compiler_wl= +lt_prog_compiler_pic= +lt_prog_compiler_static= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + if test "$GCC" = yes; then + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_static='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + ;; + + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + else + lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static='-non_shared' + ;; + + newsos6) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-static' + ;; + ccc*) + lt_prog_compiler_wl='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + + sco3.2v5*) + lt_prog_compiler_pic='-Kpic' + lt_prog_compiler_static='-dn' + ;; + + solaris*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sunos4*) + lt_prog_compiler_wl='-Qoption ld ' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic='-Kconform_pic' + lt_prog_compiler_static='-Bstatic' + fi + ;; + + uts4*) + lt_prog_compiler_pic='-pic' + lt_prog_compiler_static='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic" >&5 +$as_echo "$lt_prog_compiler_pic" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } +if ${lt_prog_compiler_pic_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:7066: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:7070: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works" >&5 +$as_echo "$lt_prog_compiler_pic_works" >&6; } + +if test x"$lt_prog_compiler_pic_works" = xyes; then + case $lt_prog_compiler_pic in + "" | " "*) ;; + *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; + esac +else + lt_prog_compiler_pic= + lt_prog_compiler_can_build_shared=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic= + ;; + *) + lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:7126: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:7130: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag= + enable_shared_with_static_runtimes=no + archive_cmds= + archive_expsym_cmds= + old_archive_From_new_cmds= + old_archive_from_expsyms_cmds= + export_dynamic_flag_spec= + whole_archive_flag_spec= + thread_safe_flag_spec= + hardcode_libdir_flag_spec= + hardcode_libdir_flag_spec_ld= + hardcode_libdir_separator= + hardcode_direct=no + hardcode_minus_L=no + hardcode_shlibpath_var=unsupported + link_all_deplibs=unknown + hardcode_automatic=no + module_cmds= + module_expsym_cmds= + always_export_symbols=no + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + ld_shlibs=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + ld_shlibs=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec='-L$libdir' + allow_undefined_flag=unsupported + always_export_symbols=no + enable_shared_with_static_runtimes=yes + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + ld_shlibs=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + + sunos4*) + archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + archive_expsym_cmds='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + archive_expsym_cmds="$tmp_archive_cmds" + fi + else + ld_shlibs=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + + if test "$ld_shlibs" = yes; then + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag=unsupported + always_export_symbols=yes + archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds='' + hardcode_direct=yes + hardcode_libdir_separator=':' + link_all_deplibs=yes + + if test "$GCC" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct=yes + else + # We have old collect2 + hardcode_direct=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L=yes + hardcode_libdir_flag_spec='-L$libdir' + hardcode_libdir_separator= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag="-z nodefs" + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag=' ${wl}-bernotok' + allow_undefined_flag=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec=' ' + archive_cmds_need_lc=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + # see comment about different semantics on the GNU ld section + ld_shlibs=no + ;; + + bsdi4*) + export_dynamic_flag_spec=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_From_new_cmds='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + enable_shared_with_static_runtimes=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + archive_cmds_need_lc=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + whole_archive_flag_spec='-all_load $convenience' + link_all_deplibs=yes + else + ld_shlibs=no + fi + ;; + + dgux*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + freebsd1*) + ld_shlibs=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + export_dynamic_flag_spec='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld='+b $libdir' + hardcode_libdir_separator=: + hardcode_direct=no + hardcode_shlibpath_var=no + ;; + ia64*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=no + hardcode_shlibpath_var=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + *) + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + export_dynamic_flag_spec='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_ld='-rpath $libdir' + fi + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + link_all_deplibs=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + newsos6) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_shlibpath_var=no + ;; + + openbsd*) + hardcode_direct=yes + hardcode_shlibpath_var=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-R$libdir' + ;; + *) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + allow_undefined_flag=unsupported + archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_From_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec='-rpath $libdir' + fi + hardcode_libdir_separator=: + ;; + + sco3.2v5*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + no_undefined_flag=' -z text' + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_shlibpath_var=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;; + esac + link_all_deplibs=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds='$CC -r -o $output$reload_objs' + hardcode_direct=no + ;; + motorola) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv4.3*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs=yes + fi + ;; + + sysv4.2uw2*) + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=no + hardcode_shlibpath_var=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + no_undefined_flag='${wl}-z ${wl}text' + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv5*) + no_undefined_flag=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + hardcode_libdir_flag_spec= + hardcode_shlibpath_var=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + *) + ld_shlibs=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +$as_echo "$ld_shlibs" >&6; } +test "$ld_shlibs" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag + allow_undefined_flag= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc=no + else + archive_cmds_need_lc=yes + fi + allow_undefined_flag=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc" >&5 +$as_echo "$archive_cmds_need_lc" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action= +if test -n "$hardcode_libdir_flag_spec" || \ + test -n "$runpath_var " || \ + test "X$hardcode_automatic"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, )" != no && + test "$hardcode_minus_L" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +$as_echo "$hardcode_action" >&6; } + +if test "$hardcode_action" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + +# Report which librarie types wil actually be built +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } +test "$can_build_shared" = "no" && enable_shared=no + +# On AIX, shared libraries and static libraries use the same namespace, and +# are all built from PIC. +case "$host_os" in +aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + +aix4* | aix5*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + darwin* | rhapsody*) + if test "$GCC" = yes; then + archive_cmds_need_lc=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + output_verbose_link_cmd='echo' + archive_cmds='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring' + module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + archive_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + module_expsym_cmds='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + whole_archive_flag_spec='-all_load $convenience' + link_all_deplibs=yes + else + ld_shlibs=no + fi + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } +# Make sure either enable_shared or enable_static is yes. +test "$enable_shared" = yes || enable_static=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler \ + CC \ + LD \ + lt_prog_compiler_wl \ + lt_prog_compiler_pic \ + lt_prog_compiler_static \ + lt_prog_compiler_no_builtin_flag \ + export_dynamic_flag_spec \ + thread_safe_flag_spec \ + whole_archive_flag_spec \ + enable_shared_with_static_runtimes \ + old_archive_cmds \ + old_archive_from_new_cmds \ + predep_objects \ + postdep_objects \ + predeps \ + postdeps \ + compiler_lib_search_path \ + archive_cmds \ + archive_expsym_cmds \ + postinstall_cmds \ + postuninstall_cmds \ + old_archive_from_expsyms_cmds \ + allow_undefined_flag \ + no_undefined_flag \ + export_symbols_cmds \ + hardcode_libdir_flag_spec \ + hardcode_libdir_flag_spec_ld \ + hardcode_libdir_separator \ + hardcode_automatic \ + module_cmds \ + module_expsym_cmds \ + lt_cv_prog_compiler_c_o \ + exclude_expsyms \ + include_expsyms; do + + case $var in + old_archive_cmds | \ + old_archive_from_new_cmds | \ + archive_cmds | \ + archive_expsym_cmds | \ + module_cmds | \ + module_expsym_cmds | \ + old_archive_from_expsyms_cmds | \ + export_symbols_cmds | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="${ofile}T" + trap "$rm \"$cfgfile\"; exit 1" 1 2 15 + $rm -f "$cfgfile" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ofile" >&5 +$as_echo "$as_me: creating $ofile" >&6;} + + cat <<__EOF__ >> "$cfgfile" +#! $SHELL + +# `$echo "$cfgfile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP) +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 +# Free Software Foundation, Inc. +# +# This file is part of GNU Libtool: +# Originally by Gordon Matzigkeit , 1996 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="$SED -e s/^X//" + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi + +# The names of the tagged configurations supported by this script. +available_tags= + +# ### BEGIN LIBTOOL CONFIG + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU C compiler? +with_gcc=$GCC + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# ### END LIBTOOL CONFIG + +__EOF__ + + + case $host_os in + aix3*) + cat <<\EOF >> "$cfgfile" + +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +EOF + ;; + esac + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1) + + mv -f "$cfgfile" "$ofile" || \ + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + +# Check whether --with-tags was given. +if test "${with_tags+set}" = set; then : + withval=$with_tags; tagnames="$withval" +fi + + +if test -f "$ltmain" && test -n "$tagnames"; then + if test ! -f "${ofile}"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: output file \`$ofile' does not exist" >&5 +$as_echo "$as_me: WARNING: output file \`$ofile' does not exist" >&2;} + fi + + if test -z "$LTCC"; then + eval "`$SHELL ${ofile} --config | grep '^LTCC='`" + if test -z "$LTCC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: output file \`$ofile' does not look like a libtool script" >&5 +$as_echo "$as_me: WARNING: output file \`$ofile' does not look like a libtool script" >&2;} + else + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&5 +$as_echo "$as_me: WARNING: using \`LTCC=$LTCC', extracted from \`$ofile'" >&2;} + fi + fi + + # Extract list of available tagged configurations in $ofile. + # Note that this assumes the entire list is on one line. + available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=\(.*$\)/\1/' -e 's/\"//g'` + + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for tagname in $tagnames; do + IFS="$lt_save_ifs" + # Check whether tagname contains only valid characters + case `$echo "X$tagname" | $Xsed -e 's:[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]::g'` in + "") ;; + *) as_fn_error $? "invalid tag name: $tagname" "$LINENO" 5 + ;; + esac + + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null + then + as_fn_error $? "tag name \"$tagname\" already exists" "$LINENO" 5 + fi + + # Update the list of available tags. + if test -n "$tagname"; then + echo appending configuration tag \"$tagname\" to $ofile + + case $tagname in + CXX) + if test -n "$CXX" && test "X$CXX" != "Xno"; then + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + + +archive_cmds_need_lc_CXX=no +allow_undefined_flag_CXX= +always_export_symbols_CXX=no +archive_expsym_cmds_CXX= +export_dynamic_flag_spec_CXX= +hardcode_direct_CXX=no +hardcode_libdir_flag_spec_CXX= +hardcode_libdir_flag_spec_ld_CXX= +hardcode_libdir_separator_CXX= +hardcode_minus_L_CXX=no +hardcode_automatic_CXX=no +module_cmds_CXX= +module_expsym_cmds_CXX= +link_all_deplibs_CXX=unknown +old_archive_cmds_CXX=$old_archive_cmds +no_undefined_flag_CXX= +whole_archive_flag_spec_CXX= +enable_shared_with_static_runtimes_CXX=no + +# Dependencies to place before and after the object being linked: +predep_objects_CXX= +postdep_objects_CXX= +predeps_CXX= +postdeps_CXX= +compiler_lib_search_path_CXX= + +# Source file extension for C++ test sources. +ac_ext=cc + +# Object file extension for compiled C++ test sources. +objext=o +objext_CXX=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(int, char *) { return(0); }\n' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_LD=$LD +lt_save_GCC=$GCC +GCC=$GXX +lt_save_with_gnu_ld=$with_gnu_ld +lt_save_path_LD=$lt_cv_path_LD +if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx +else + unset lt_cv_prog_gnu_ld +fi +if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX +else + unset lt_cv_path_LD +fi +test -z "${LDCXX+set}" || LD=$LDCXX +CC=${CXX-"c++"} +compiler=$CC +compiler_CXX=$CC +cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'` + +# We don't want -fno-exception wen compiling C++ code, so set the +# no_builtin_flag separately +if test "$GXX" = yes; then + lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' +else + lt_prog_compiler_no_builtin_flag_CXX= +fi + +if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'` + while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do + ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some GNU ld's only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU ld's only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | \ + grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_CXX= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + +else + GXX=no + with_gnu_ld=no + wlarc= +fi + +# PORTME: fill in a description of your system's C++ link characteristics +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } +ld_shlibs_CXX=yes +case $host_os in + aix3*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_CXX='' + hardcode_direct_CXX=yes + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + + if test "$GXX" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct_CXX=yes + else + # We have old collect2 + hardcode_direct_CXX=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_CXX=yes + hardcode_libdir_flag_spec_CXX='-L$libdir' + hardcode_libdir_separator_CXX= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols_CXX=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_CXX='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + + archive_expsym_cmds_CXX="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_CXX="-z nodefs" + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_CXX=' ${wl}-bernotok' + allow_undefined_flag_CXX=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols_CXX=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_CXX=' ' + archive_cmds_need_lc_CXX=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_CXX='-L$libdir' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=no + enable_shared_with_static_runtimes_CXX=yes + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs_CXX=no + fi + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes; then + archive_cmds_need_lc_CXX=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag_CXX='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag_CXX='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag_CXX='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag_CXX='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds_CXX='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds_CXX='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds_CXX='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds_CXX='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct_CXX=no + hardcode_automatic_CXX=yes + hardcode_shlibpath_var_CXX=unsupported + whole_archive_flag_spec_CXX='-all_load $convenience' + link_all_deplibs_CXX=yes + else + ld_shlibs_CXX=no + fi + ;; + + dgux*) + case $cc_basename in + ec++) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + ghcx) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + freebsd12*) + # C++ shared libraries reported to be fairly broken before switch to ELF + ld_shlibs_CXX=no + ;; + freebsd-elf*) + archive_cmds_need_lc_CXX=no + ;; + freebsd* | kfreebsd*-gnu) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + ld_shlibs_CXX=yes + ;; + gnu*) + ;; + hpux9*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC) + archive_cmds_CXX='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes; then + archive_cmds_CXX='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld_CXX='+b $libdir' + hardcode_libdir_separator_CXX=: + ;; + ia64*) + hardcode_libdir_flag_spec_CXX='-L$libdir' + ;; + *) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + ;; + esac + fi + case "$host_cpu" in + hppa*64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + ;; + ia64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + *) + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC) + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_CXX='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs' + ;; + *) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case "$host_cpu" in + ia64*|hppa*64*) + archive_cmds_CXX='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs' + ;; + *) + archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + irix5* | irix6*) + case $cc_basename in + CC) + # SGI C++ + archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + else + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib' + fi + fi + link_all_deplibs_CXX=yes + ;; + esac + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + ;; + linux*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | grep "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + + hardcode_libdir_flag_spec_CXX='${wl}--rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc) + # Intel C++ + with_gnu_ld=yes + archive_cmds_need_lc_CXX=no + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + cxx) + # Compaq C++ + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + esac + ;; + lynxos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + m88k*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + mvs*) + case $cc_basename in + cxx) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + osf3*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + + ;; + RCC) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx) + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + osf4* | osf5*) + case $cc_basename in + KCC) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' + ;; + RCC) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx) + allow_undefined_flag_CXX=' -expect_unresolved \*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib' + archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp `test -n "$verstring" && echo -set_version $verstring` -update_registry $objdir/so_locations -o $lib~ + $rm $lib.exp' + + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "ld" | grep -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + psos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + sco*) + archive_cmds_need_lc_CXX=no + case $cc_basename in + CC) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + lcc) + # Lucid + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + solaris*) + case $cc_basename in + CC) + # Sun C++ 4.2, 5.x and Centerline C++ + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_shlibpath_var_CXX=no + case $host_os in + solaris2.0-5 | solaris2.0-5.*) ;; + *) + # The C++ compiler is used as linker so we must use $wl + # flag to pass the commands to the underlying system + # linker. + # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + link_all_deplibs_CXX=yes + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep "\-[LR]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + gcx) + # Green Hills C++ Compiler + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + no_undefined_flag_CXX=' ${wl}-z ${wl}defs' + if $CC --version | grep -v '^2\.7' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\"" + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep \"\-L\"" + fi + + hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir' + fi + ;; + esac + ;; + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + archive_cmds_need_lc_CXX=no + ;; + tandem*) + case $cc_basename in + NCC) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + vxworks*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +GCC_CXX="$GXX" +LD_CXX="$LD" + + +cat > conftest.$ac_ext <&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + # The `*' in the case matches for architectures that use `case' in + # $output_verbose_cmd can trigger glob expansion during the loop + # eval without this substitution. + output_verbose_link_cmd="`$echo \"X$output_verbose_link_cmd\" | $Xsed -e \"$no_glob_subst\"`" + + for p in `eval $output_verbose_link_cmd`; do + case $p in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" \ + || test $p = "-R"; then + prev=$p + continue + else + prev= + fi + + if test "$pre_test_object_deps_done" = no; then + case $p in + -L* | -R*) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$compiler_lib_search_path_CXX"; then + compiler_lib_search_path_CXX="${prev}${p}" + else + compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$postdeps_CXX"; then + postdeps_CXX="${prev}${p}" + else + postdeps_CXX="${postdeps_CXX} ${prev}${p}" + fi + fi + ;; + + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$predep_objects_CXX"; then + predep_objects_CXX="$p" + else + predep_objects_CXX="$predep_objects_CXX $p" + fi + else + if test -z "$postdep_objects_CXX"; then + postdep_objects_CXX="$p" + else + postdep_objects_CXX="$postdep_objects_CXX $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling CXX test program" +fi + +$rm -f confest.$objext + +case " $postdeps_CXX " in +*" -lc "*) archive_cmds_need_lc_CXX=no ;; +esac + +lt_prog_compiler_wl_CXX= +lt_prog_compiler_pic_CXX= +lt_prog_compiler_static_CXX= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + fi + ;; + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4' + ;; + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | os2* | pw32*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_CXX='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + lt_prog_compiler_pic_CXX= + ;; + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_CXX=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + else + case $host_os in + aix4* | aix5*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + else + lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68) + # Green Hills C++ Compiler + # _LT_AC_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + dgux*) + case $cc_basename in + ec++) + lt_prog_compiler_pic_CXX='-KPIC' + ;; + ghcx) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | kfreebsd*-gnu) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive" + if test "$host_cpu" != ia64; then + lt_prog_compiler_pic_CXX='+Z' + fi + ;; + aCC) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive" + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_CXX='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux*) + case $cc_basename in + KCC) + # KAI C++ Compiler + lt_prog_compiler_wl_CXX='--backend -Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + ;; + icpc) + # Intel C++ + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-static' + ;; + cxx) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx) + lt_prog_compiler_pic_CXX='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd*) + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC) + lt_prog_compiler_wl_CXX='--backend -Wl,' + ;; + RCC) + # Rational C++ 2.4.1 + lt_prog_compiler_pic_CXX='-pic' + ;; + cxx) + # Digital/Compaq C++ + lt_prog_compiler_wl_CXX='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + sco*) + case $cc_basename in + CC) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + *) + ;; + esac + ;; + solaris*) + case $cc_basename in + CC) + # Sun C++ 4.2, 5.x and Centerline C++ + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + gcx) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC) + # Sun C++ 4.x + lt_prog_compiler_pic_CXX='-pic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + lcc) + # Lucid + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC) + # NonStop-UX NCC 3.20 + lt_prog_compiler_pic_CXX='-KPIC' + ;; + *) + ;; + esac + ;; + unixware*) + ;; + vxworks*) + ;; + *) + lt_prog_compiler_can_build_shared_CXX=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_CXX" >&5 +$as_echo "$lt_prog_compiler_pic_CXX" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_CXX"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } +if ${lt_prog_compiler_pic_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works_CXX=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:11153: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:11157: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works_CXX=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works_CXX" >&5 +$as_echo "$lt_prog_compiler_pic_works_CXX" >&6; } + +if test x"$lt_prog_compiler_pic_works_CXX" = xyes; then + case $lt_prog_compiler_pic_CXX in + "" | " "*) ;; + *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;; + esac +else + lt_prog_compiler_pic_CXX= + lt_prog_compiler_can_build_shared_CXX=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_CXX= + ;; + *) + lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:11213: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:11217: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + case $host_os in + aix4* | aix5*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + export_symbols_cmds_CXX="$ltdll_cmds" + ;; + cygwin* | mingw*) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_CXX" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_CXX=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_CXX in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_CXX + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_CXX + allow_undefined_flag_CXX= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_CXX 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc_CXX=no + else + archive_cmds_need_lc_CXX=yes + fi + allow_undefined_flag_CXX=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc_CXX" >&5 +$as_echo "$archive_cmds_need_lc_CXX" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_CXX= +if test -n "$hardcode_libdir_flag_spec_CXX" || \ + test -n "$runpath_var CXX" || \ + test "X$hardcode_automatic_CXX"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct_CXX" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, CXX)" != no && + test "$hardcode_minus_L_CXX" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_CXX=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_CXX=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_CXX=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +$as_echo "$hardcode_action_CXX" >&6; } + +if test "$hardcode_action_CXX" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_cxx_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" +else + ac_fn_cxx_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_CXX \ + CC_CXX \ + LD_CXX \ + lt_prog_compiler_wl_CXX \ + lt_prog_compiler_pic_CXX \ + lt_prog_compiler_static_CXX \ + lt_prog_compiler_no_builtin_flag_CXX \ + export_dynamic_flag_spec_CXX \ + thread_safe_flag_spec_CXX \ + whole_archive_flag_spec_CXX \ + enable_shared_with_static_runtimes_CXX \ + old_archive_cmds_CXX \ + old_archive_from_new_cmds_CXX \ + predep_objects_CXX \ + postdep_objects_CXX \ + predeps_CXX \ + postdeps_CXX \ + compiler_lib_search_path_CXX \ + archive_cmds_CXX \ + archive_expsym_cmds_CXX \ + postinstall_cmds_CXX \ + postuninstall_cmds_CXX \ + old_archive_from_expsyms_cmds_CXX \ + allow_undefined_flag_CXX \ + no_undefined_flag_CXX \ + export_symbols_cmds_CXX \ + hardcode_libdir_flag_spec_CXX \ + hardcode_libdir_flag_spec_ld_CXX \ + hardcode_libdir_separator_CXX \ + hardcode_automatic_CXX \ + module_cmds_CXX \ + module_expsym_cmds_CXX \ + lt_cv_prog_compiler_c_o_CXX \ + exclude_expsyms_CXX \ + include_expsyms_CXX; do + + case $var in + old_archive_cmds_CXX | \ + old_archive_from_new_cmds_CXX | \ + archive_cmds_CXX | \ + archive_expsym_cmds_CXX | \ + module_cmds_CXX | \ + module_expsym_cmds_CXX | \ + old_archive_from_expsyms_cmds_CXX | \ + export_symbols_cmds_CXX | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_CXX + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_CXX + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_CXX +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_CXX + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_CXX + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_CXX + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_CXX + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_CXX" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC=$lt_save_CC +LDCXX=$LD +LD=$lt_save_LD +GCC=$lt_save_GCC +with_gnu_ldcxx=$with_gnu_ld +with_gnu_ld=$lt_save_with_gnu_ld +lt_cv_path_LDCXX=$lt_cv_path_LD +lt_cv_path_LD=$lt_save_path_LD +lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld +lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld + + else + tagname="" + fi + ;; + + F77) + if test -n "$F77" && test "X$F77" != "Xno"; then + +ac_ext=f +ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5' +ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_f77_compiler_gnu + + +archive_cmds_need_lc_F77=no +allow_undefined_flag_F77= +always_export_symbols_F77=no +archive_expsym_cmds_F77= +export_dynamic_flag_spec_F77= +hardcode_direct_F77=no +hardcode_libdir_flag_spec_F77= +hardcode_libdir_flag_spec_ld_F77= +hardcode_libdir_separator_F77= +hardcode_minus_L_F77=no +hardcode_automatic_F77=no +module_cmds_F77= +module_expsym_cmds_F77= +link_all_deplibs_F77=unknown +old_archive_cmds_F77=$old_archive_cmds +no_undefined_flag_F77= +whole_archive_flag_spec_F77= +enable_shared_with_static_runtimes_F77=no + +# Source file extension for f77 test sources. +ac_ext=f + +# Object file extension for compiled f77 test sources. +objext=o +objext_F77=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code=" subroutine t\n return\n end\n" + +# Code to be used in simple link tests +lt_simple_link_test_code=" program t\n end\n" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +CC=${F77-"f77"} +compiler=$CC +compiler_F77=$CC +cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'` + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } +test "$can_build_shared" = "no" && enable_shared=no + +# On AIX, shared libraries and static libraries use the same namespace, and +# are all built from PIC. +case "$host_os" in +aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; +aix4* | aix5*) + test "$enable_shared" = yes && enable_static=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } +# Make sure either enable_shared or enable_static is yes. +test "$enable_shared" = yes || enable_static=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + +test "$ld_shlibs_F77" = no && can_build_shared=no + +GCC_F77="$G77" +LD_F77="$LD" + +lt_prog_compiler_wl_F77= +lt_prog_compiler_pic_F77= +lt_prog_compiler_static_F77= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + if test "$GCC" = yes; then + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_static_F77='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_F77='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_F77='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_F77='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_F77='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared_F77=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_F77=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_F77='-fPIC' + ;; + esac + ;; + + *) + lt_prog_compiler_pic_F77='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl_F77='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_F77='-Bstatic' + else + lt_prog_compiler_static_F77='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_F77='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl_F77='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_F77='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static_F77='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl_F77='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static_F77='-non_shared' + ;; + + newsos6) + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-static' + ;; + ccc*) + lt_prog_compiler_wl_F77='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static_F77='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl_F77='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static_F77='-non_shared' + ;; + + sco3.2v5*) + lt_prog_compiler_pic_F77='-Kpic' + lt_prog_compiler_static_F77='-dn' + ;; + + solaris*) + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + sunos4*) + lt_prog_compiler_wl_F77='-Qoption ld ' + lt_prog_compiler_pic_F77='-PIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + lt_prog_compiler_wl_F77='-Wl,' + lt_prog_compiler_pic_F77='-KPIC' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic_F77='-Kconform_pic' + lt_prog_compiler_static_F77='-Bstatic' + fi + ;; + + uts4*) + lt_prog_compiler_pic_F77='-pic' + lt_prog_compiler_static_F77='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared_F77=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_F77" >&5 +$as_echo "$lt_prog_compiler_pic_F77" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_F77"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_F77 works... " >&6; } +if ${lt_prog_compiler_pic_works_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works_F77=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_F77" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:13187: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:13191: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works_F77=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works_F77" >&5 +$as_echo "$lt_prog_compiler_pic_works_F77" >&6; } + +if test x"$lt_prog_compiler_pic_works_F77" = xyes; then + case $lt_prog_compiler_pic_F77 in + "" | " "*) ;; + *) lt_prog_compiler_pic_F77=" $lt_prog_compiler_pic_F77" ;; + esac +else + lt_prog_compiler_pic_F77= + lt_prog_compiler_can_build_shared_F77=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_F77= + ;; + *) + lt_prog_compiler_pic_F77="$lt_prog_compiler_pic_F77" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_F77+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_F77=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:13247: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:13251: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o_F77=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_F77" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_F77" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_F77" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag_F77= + enable_shared_with_static_runtimes_F77=no + archive_cmds_F77= + archive_expsym_cmds_F77= + old_archive_From_new_cmds_F77= + old_archive_from_expsyms_cmds_F77= + export_dynamic_flag_spec_F77= + whole_archive_flag_spec_F77= + thread_safe_flag_spec_F77= + hardcode_libdir_flag_spec_F77= + hardcode_libdir_flag_spec_ld_F77= + hardcode_libdir_separator_F77= + hardcode_direct_F77=no + hardcode_minus_L_F77=no + hardcode_shlibpath_var_F77=unsupported + link_all_deplibs_F77=unknown + hardcode_automatic_F77=no + module_cmds_F77= + module_expsym_cmds_F77= + always_export_symbols_F77=no + export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms_F77= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms_F77="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + ld_shlibs_F77=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs_F77=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_minus_L_F77=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + ld_shlibs_F77=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_F77=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_F77='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_F77=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, F77) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_F77='-L$libdir' + allow_undefined_flag_F77=unsupported + always_export_symbols_F77=no + enable_shared_with_static_runtimes_F77=yes + export_symbols_cmds_F77='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_F77='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_F77='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + ld_shlibs_F77=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_F77=no + fi + ;; + + sunos4*) + archive_cmds_F77='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds_F77="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + archive_expsym_cmds_F77='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + archive_expsym_cmds_F77="$tmp_archive_cmds" + fi + else + ld_shlibs_F77=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_F77=no + fi + ;; + esac + + if test "$ld_shlibs_F77" = yes; then + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_F77='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_F77='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_F77="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_F77= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag_F77=unsupported + always_export_symbols_F77=yes + archive_expsym_cmds_F77='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L_F77=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct_F77=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds_F77='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_F77='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_F77='' + hardcode_direct_F77=yes + hardcode_libdir_separator_F77=':' + link_all_deplibs_F77=yes + + if test "$GCC" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct_F77=yes + else + # We have old collect2 + hardcode_direct_F77=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_F77=yes + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_libdir_separator_F77= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols_F77=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_F77='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat > conftest.$ac_ext <<_ACEOF + program main + + end +_ACEOF +if ac_fn_f77_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds_F77="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_F77='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_F77="-z nodefs" + archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat > conftest.$ac_ext <<_ACEOF + program main + + end +_ACEOF +if ac_fn_f77_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_F77='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_F77=' ${wl}-bernotok' + allow_undefined_flag_F77=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols_F77=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_F77=' ' + archive_cmds_need_lc_F77=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds_F77="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + archive_cmds_F77='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_minus_L_F77=yes + # see comment about different semantics on the GNU ld section + ld_shlibs_F77=no + ;; + + bsdi4*) + export_dynamic_flag_spec_F77=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_F77=' ' + allow_undefined_flag_F77=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_F77='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_From_new_cmds_F77='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds_F77='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + enable_shared_with_static_runtimes_F77=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + archive_cmds_need_lc_F77=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag_F77='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag_F77='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag_F77='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag_F77='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds_F77='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds_F77='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds_F77='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds_F77='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct_F77=no + hardcode_automatic_F77=yes + hardcode_shlibpath_var_F77=unsupported + whole_archive_flag_spec_F77='-all_load $convenience' + link_all_deplibs_F77=yes + else + ld_shlibs_F77=no + fi + ;; + + dgux*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_shlibpath_var_F77=no + ;; + + freebsd1*) + ld_shlibs_F77=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes + hardcode_minus_L_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + archive_cmds_F77='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds_F77='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds_F77='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_F77=: + hardcode_direct_F77=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_F77=yes + export_dynamic_flag_spec_F77='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_F77='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_F77='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_F77='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + archive_cmds_F77='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld_F77='+b $libdir' + hardcode_libdir_separator_F77=: + hardcode_direct_F77=no + hardcode_shlibpath_var_F77=no + ;; + ia64*) + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_direct_F77=no + hardcode_shlibpath_var_F77=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_F77=yes + ;; + *) + hardcode_libdir_flag_spec_F77='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_F77=: + hardcode_direct_F77=yes + export_dynamic_flag_spec_F77='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_F77=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds_F77='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_F77='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_ld_F77='-rpath $libdir' + fi + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_F77=: + link_all_deplibs_F77=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds_F77='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + newsos6) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_F77=: + hardcode_shlibpath_var_F77=no + ;; + + openbsd*) + hardcode_direct_F77=yes + hardcode_shlibpath_var_F77=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir' + export_dynamic_flag_spec_F77='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_F77='-R$libdir' + ;; + *) + archive_cmds_F77='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_F77='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_minus_L_F77=yes + allow_undefined_flag_F77=unsupported + archive_cmds_F77='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_From_new_cmds_F77='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag_F77=' -expect_unresolved \*' + archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_F77=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag_F77=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_F77='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_F77='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag_F77=' -expect_unresolved \*' + archive_cmds_F77='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_F77='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec_F77='-rpath $libdir' + fi + hardcode_libdir_separator_F77=: + ;; + + sco3.2v5*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_F77=no + export_dynamic_flag_spec_F77='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + no_undefined_flag_F77=' -z text' + if test "$GCC" = yes; then + archive_cmds_F77='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + archive_cmds_F77='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + hardcode_libdir_flag_spec_F77='-R$libdir' + hardcode_shlibpath_var_F77=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_F77='-z allextract$convenience -z defaultextract' ;; + esac + link_all_deplibs_F77=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds_F77='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_F77='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_direct_F77=yes + hardcode_minus_L_F77=yes + hardcode_shlibpath_var_F77=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds_F77='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds_F77='$CC -r -o $output$reload_objs' + hardcode_direct_F77=no + ;; + motorola) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_F77=no + ;; + + sysv4.3*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_F77=no + export_dynamic_flag_spec_F77='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_F77=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs_F77=yes + fi + ;; + + sysv4.2uw2*) + archive_cmds_F77='$LD -G -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_F77=yes + hardcode_minus_L_F77=no + hardcode_shlibpath_var_F77=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + no_undefined_flag_F77='${wl}-z ${wl}text' + if test "$GCC" = yes; then + archive_cmds_F77='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_F77='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_F77=no + ;; + + sysv5*) + no_undefined_flag_F77=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + archive_cmds_F77='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_F77='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + hardcode_libdir_flag_spec_F77= + hardcode_shlibpath_var_F77=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + archive_cmds_F77='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_F77='-L$libdir' + hardcode_shlibpath_var_F77=no + ;; + + *) + ld_shlibs_F77=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_F77" >&5 +$as_echo "$ld_shlibs_F77" >&6; } +test "$ld_shlibs_F77" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_F77" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_F77=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_F77 in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_F77 + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_F77 + allow_undefined_flag_F77= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_F77 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc_F77=no + else + archive_cmds_need_lc_F77=yes + fi + allow_undefined_flag_F77=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc_F77" >&5 +$as_echo "$archive_cmds_need_lc_F77" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_F77= +if test -n "$hardcode_libdir_flag_spec_F77" || \ + test -n "$runpath_var F77" || \ + test "X$hardcode_automatic_F77"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct_F77" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, F77)" != no && + test "$hardcode_minus_L_F77" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_F77=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_F77=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_F77=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_F77" >&5 +$as_echo "$hardcode_action_F77" >&6; } + +if test "$hardcode_action_F77" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + + + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_F77 \ + CC_F77 \ + LD_F77 \ + lt_prog_compiler_wl_F77 \ + lt_prog_compiler_pic_F77 \ + lt_prog_compiler_static_F77 \ + lt_prog_compiler_no_builtin_flag_F77 \ + export_dynamic_flag_spec_F77 \ + thread_safe_flag_spec_F77 \ + whole_archive_flag_spec_F77 \ + enable_shared_with_static_runtimes_F77 \ + old_archive_cmds_F77 \ + old_archive_from_new_cmds_F77 \ + predep_objects_F77 \ + postdep_objects_F77 \ + predeps_F77 \ + postdeps_F77 \ + compiler_lib_search_path_F77 \ + archive_cmds_F77 \ + archive_expsym_cmds_F77 \ + postinstall_cmds_F77 \ + postuninstall_cmds_F77 \ + old_archive_from_expsyms_cmds_F77 \ + allow_undefined_flag_F77 \ + no_undefined_flag_F77 \ + export_symbols_cmds_F77 \ + hardcode_libdir_flag_spec_F77 \ + hardcode_libdir_flag_spec_ld_F77 \ + hardcode_libdir_separator_F77 \ + hardcode_automatic_F77 \ + module_cmds_F77 \ + module_expsym_cmds_F77 \ + lt_cv_prog_compiler_c_o_F77 \ + exclude_expsyms_F77 \ + include_expsyms_F77; do + + case $var in + old_archive_cmds_F77 | \ + old_archive_from_new_cmds_F77 | \ + archive_cmds_F77 | \ + archive_expsym_cmds_F77 | \ + module_cmds_F77 | \ + module_expsym_cmds_F77 | \ + old_archive_from_expsyms_cmds_F77 | \ + export_symbols_cmds_F77 | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_F77 + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_F77 + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_F77 + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_F77 + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_F77 + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_F77 + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_F77 +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_F77 + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_F77 + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_F77 + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_F77 + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_F77 + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_F77 + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_F77 +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_F77 + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_F77 + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_F77 +archive_expsym_cmds=$lt_archive_expsym_cmds_F77 +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_F77 +module_expsym_cmds=$lt_module_expsym_cmds_F77 + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_F77 + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_F77 + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_F77 + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_F77 + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_F77 + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_F77 + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_F77 + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_F77 + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_F77 + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_F77 + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_F77 + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_F77 + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_F77 + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_F77 + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_F77 + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_F77 + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_F77" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_F77 + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_F77 + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_F77 + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_F77 + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + else + tagname="" + fi + ;; + + GCJ) + if test -n "$GCJ" && test "X$GCJ" != "Xno"; then + + +# Source file extension for Java test sources. +ac_ext=java + +# Object file extension for compiled Java test sources. +objext=o +objext_GCJ=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="class foo {}\n" + +# Code to be used in simple link tests +lt_simple_link_test_code='public class conftest { public static void main(String argv) {}; }\n' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +CC=${GCJ-"gcj"} +compiler=$CC +compiler_GCJ=$CC + +# GCJ did not exist at the time GCC didn't implicitly link libc in. +archive_cmds_need_lc_GCJ=no + + +lt_prog_compiler_no_builtin_flag_GCJ= + +if test "$GCC" = yes; then + lt_prog_compiler_no_builtin_flag_GCJ=' -fno-builtin' + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:15236: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:15240: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag_GCJ="$lt_prog_compiler_no_builtin_flag_GCJ -fno-rtti -fno-exceptions" +else + : +fi + +fi + +lt_prog_compiler_wl_GCJ= +lt_prog_compiler_pic_GCJ= +lt_prog_compiler_static_GCJ= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } + + if test "$GCC" = yes; then + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_static_GCJ='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_GCJ='-Bstatic' + fi + ;; + + amigaos*) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_GCJ='-m68020 -resident32 -malways-restore-a4' + ;; + + beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_GCJ='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_GCJ='-fno-common' + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared_GCJ=no + enable_shared=no + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_GCJ=-Kconform_pic + fi + ;; + + hpux*) + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_GCJ='-fPIC' + ;; + esac + ;; + + *) + lt_prog_compiler_pic_GCJ='-fPIC' + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl_GCJ='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_GCJ='-Bstatic' + else + lt_prog_compiler_static_GCJ='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | pw32* | os2*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_GCJ='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl_GCJ='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case "$host_cpu" in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_GCJ='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static_GCJ='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl_GCJ='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static_GCJ='-non_shared' + ;; + + newsos6) + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + linux*) + case $CC in + icc* | ecc*) + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-static' + ;; + ccc*) + lt_prog_compiler_wl_GCJ='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static_GCJ='-non_shared' + ;; + esac + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl_GCJ='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static_GCJ='-non_shared' + ;; + + sco3.2v5*) + lt_prog_compiler_pic_GCJ='-Kpic' + lt_prog_compiler_static_GCJ='-dn' + ;; + + solaris*) + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + sunos4*) + lt_prog_compiler_wl_GCJ='-Qoption ld ' + lt_prog_compiler_pic_GCJ='-PIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + lt_prog_compiler_wl_GCJ='-Wl,' + lt_prog_compiler_pic_GCJ='-KPIC' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic_GCJ='-Kconform_pic' + lt_prog_compiler_static_GCJ='-Bstatic' + fi + ;; + + uts4*) + lt_prog_compiler_pic_GCJ='-pic' + lt_prog_compiler_static_GCJ='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared_GCJ=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_GCJ" >&5 +$as_echo "$lt_prog_compiler_pic_GCJ" >&6; } + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_GCJ"; then + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_GCJ works... " >&6; } +if ${lt_prog_compiler_pic_works_GCJ+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_prog_compiler_pic_works_GCJ=no + ac_outfile=conftest.$ac_objext + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_GCJ" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:15469: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:15473: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s conftest.err; then + lt_prog_compiler_pic_works_GCJ=yes + fi + fi + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic_works_GCJ" >&5 +$as_echo "$lt_prog_compiler_pic_works_GCJ" >&6; } + +if test x"$lt_prog_compiler_pic_works_GCJ" = xyes; then + case $lt_prog_compiler_pic_GCJ in + "" | " "*) ;; + *) lt_prog_compiler_pic_GCJ=" $lt_prog_compiler_pic_GCJ" ;; + esac +else + lt_prog_compiler_pic_GCJ= + lt_prog_compiler_can_build_shared_GCJ=no +fi + +fi +case "$host_os" in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_GCJ= + ;; + *) + lt_prog_compiler_pic_GCJ="$lt_prog_compiler_pic_GCJ" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_GCJ+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_GCJ=no + $rm -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:15529: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:15533: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + if test ! -s out/conftest.err; then + lt_cv_prog_compiler_c_o_GCJ=yes + fi + fi + chmod u+w . + $rm conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files + $rm out/* && rmdir out + cd .. + rmdir conftest + $rm conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_GCJ" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_GCJ" >&6; } + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_GCJ" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $rm conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag_GCJ= + enable_shared_with_static_runtimes_GCJ=no + archive_cmds_GCJ= + archive_expsym_cmds_GCJ= + old_archive_From_new_cmds_GCJ= + old_archive_from_expsyms_cmds_GCJ= + export_dynamic_flag_spec_GCJ= + whole_archive_flag_spec_GCJ= + thread_safe_flag_spec_GCJ= + hardcode_libdir_flag_spec_GCJ= + hardcode_libdir_flag_spec_ld_GCJ= + hardcode_libdir_separator_GCJ= + hardcode_direct_GCJ=no + hardcode_minus_L_GCJ=no + hardcode_shlibpath_var_GCJ=unsupported + link_all_deplibs_GCJ=unknown + hardcode_automatic_GCJ=no + module_cmds_GCJ= + module_expsym_cmds_GCJ= + always_export_symbols_GCJ=no + export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms_GCJ= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms_GCJ="_GLOBAL_OFFSET_TABLE_" + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + openbsd*) + with_gnu_ld=no + ;; + esac + + ld_shlibs_GCJ=yes + if test "$with_gnu_ld" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # See if GNU ld supports shared libraries. + case $host_os in + aix3* | aix4* | aix5*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs_GCJ=no + cat <&2 + +*** Warning: the GNU linker, at least up to release 2.9.1, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to modify your PATH +*** so that a non-GNU linker is found, and then restart. + +EOF + fi + ;; + + amigaos*) + archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_minus_L_GCJ=yes + + # Samuel A. Falvo II reports + # that the semantics of dynamic libraries on AmigaOS, at least up + # to version 4, is to share data among multiple programs linked + # with the same dynamic library. Since this doesn't match the + # behavior of shared libraries on other platforms, we can't use + # them. + ld_shlibs_GCJ=no + ;; + + beos*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_GCJ=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_GCJ='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_GCJ=no + fi + ;; + + cygwin* | mingw* | pw32*) + # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, GCJ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_GCJ='-L$libdir' + allow_undefined_flag_GCJ=unsupported + always_export_symbols_GCJ=no + enable_shared_with_static_runtimes_GCJ=yes + export_symbols_cmds_GCJ='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGS] /s/.* \([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols' + + if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_GCJ='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib' + else + ld_shlibs=no + fi + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_GCJ='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris* | sysv5*) + if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then + ld_shlibs_GCJ=no + cat <&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +EOF + elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_GCJ=no + fi + ;; + + sunos4*) + archive_cmds_GCJ='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + linux*) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_cmds_GCJ="$tmp_archive_cmds" + supports_anon_versioning=no + case `$LD -v 2>/dev/null` in + *\ 01.* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + if test $supports_anon_versioning = yes; then + archive_expsym_cmds_GCJ='$echo "{ global:" > $output_objdir/$libname.ver~ +cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ +$echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + else + archive_expsym_cmds_GCJ="$tmp_archive_cmds" + fi + else + ld_shlibs_GCJ=no + fi + ;; + + *) + if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs_GCJ=no + fi + ;; + esac + + if test "$ld_shlibs_GCJ" = yes; then + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_GCJ='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_GCJ='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_GCJ="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_GCJ= + fi + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag_GCJ=unsupported + always_export_symbols_GCJ=yes + archive_expsym_cmds_GCJ='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L_GCJ=yes + if test "$GCC" = yes && test -z "$link_static_flag"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct_GCJ=unsupported + fi + ;; + + aix4* | aix5*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + if $NM -V 2>&1 | grep 'GNU' > /dev/null; then + export_symbols_cmds_GCJ='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_GCJ='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$2 == "T") || (\$2 == "D") || (\$2 == "B")) && (substr(\$3,1,1) != ".")) { print \$3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix5*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_GCJ='' + hardcode_direct_GCJ=yes + hardcode_libdir_separator_GCJ=':' + link_all_deplibs_GCJ=yes + + if test "$GCC" = yes; then + case $host_os in aix4.012|aix4.012.*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && \ + strings "$collect2name" | grep resolve_lib_name >/dev/null + then + # We have reworked collect2 + hardcode_direct_GCJ=yes + else + # We have old collect2 + hardcode_direct_GCJ=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_GCJ=yes + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_libdir_separator_GCJ= + fi + esac + shared_flag='-shared' + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols_GCJ=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_GCJ='-berok' + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds_GCJ="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_GCJ='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_GCJ="-z nodefs" + archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an empty executable. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + +aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'` +# Check for a 64-bit object if we didn't find anything. +if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } +}'`; fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi + + hardcode_libdir_flag_spec_GCJ='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_GCJ=' ${wl}-bernotok' + allow_undefined_flag_GCJ=' ${wl}-berok' + # -bexpall does not export symbols beginning with underscore (_) + always_export_symbols_GCJ=yes + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_GCJ=' ' + archive_cmds_need_lc_GCJ=yes + # This is similar to how AIX traditionally builds it's shared libraries. + archive_expsym_cmds_GCJ="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + archive_cmds_GCJ='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_minus_L_GCJ=yes + # see comment about different semantics on the GNU ld section + ld_shlibs_GCJ=no + ;; + + bsdi4*) + export_dynamic_flag_spec_GCJ=-rdynamic + ;; + + cygwin* | mingw* | pw32*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_GCJ=' ' + allow_undefined_flag_GCJ=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_GCJ='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_From_new_cmds_GCJ='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds_GCJ='lib /OUT:$oldlib$oldobjs$old_deplibs' + fix_srcfile_path='`cygpath -w "$srcfile"`' + enable_shared_with_static_runtimes_GCJ=yes + ;; + + darwin* | rhapsody*) + if test "$GXX" = yes ; then + archive_cmds_need_lc_GCJ=no + case "$host_os" in + rhapsody* | darwin1.[012]) + allow_undefined_flag_GCJ='-undefined suppress' + ;; + *) # Darwin 1.3 on + if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then + allow_undefined_flag_GCJ='-flat_namespace -undefined suppress' + else + case ${MACOSX_DEPLOYMENT_TARGET} in + 10.[012]) + allow_undefined_flag_GCJ='-flat_namespace -undefined suppress' + ;; + 10.*) + allow_undefined_flag_GCJ='-undefined dynamic_lookup' + ;; + esac + fi + ;; + esac + lt_int_apple_cc_single_mod=no + output_verbose_link_cmd='echo' + if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then + lt_int_apple_cc_single_mod=yes + fi + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_cmds_GCJ='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + else + archive_cmds_GCJ='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring' + fi + module_cmds_GCJ='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags' + # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's + if test "X$lt_int_apple_cc_single_mod" = Xyes ; then + archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + else + archive_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + module_expsym_cmds_GCJ='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}' + hardcode_direct_GCJ=no + hardcode_automatic_GCJ=yes + hardcode_shlibpath_var_GCJ=unsupported + whole_archive_flag_spec_GCJ='-all_load $convenience' + link_all_deplibs_GCJ=yes + else + ld_shlibs_GCJ=no + fi + ;; + + dgux*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_shlibpath_var_GCJ=no + ;; + + freebsd1*) + ld_shlibs_GCJ=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2*) + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes + hardcode_minus_L_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | kfreebsd*-gnu) + archive_cmds_GCJ='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds_GCJ='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds_GCJ='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + hardcode_direct_GCJ=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_GCJ=yes + export_dynamic_flag_spec_GCJ='${wl}-E' + ;; + + hpux10* | hpux11*) + if test "$GCC" = yes -a "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_GCJ='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_GCJ='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case "$host_cpu" in + hppa*64*|ia64*) + archive_cmds_GCJ='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags' + ;; + *) + archive_cmds_GCJ='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + ;; + esac + fi + if test "$with_gnu_ld" = no; then + case "$host_cpu" in + hppa*64*) + hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir' + hardcode_libdir_flag_spec_ld_GCJ='+b $libdir' + hardcode_libdir_separator_GCJ=: + hardcode_direct_GCJ=no + hardcode_shlibpath_var_GCJ=no + ;; + ia64*) + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_direct_GCJ=no + hardcode_shlibpath_var_GCJ=no + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_GCJ=yes + ;; + *) + hardcode_libdir_flag_spec_GCJ='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + hardcode_direct_GCJ=yes + export_dynamic_flag_spec_GCJ='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L_GCJ=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds_GCJ='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_GCJ='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_ld_GCJ='-rpath $libdir' + fi + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + link_all_deplibs_GCJ=yes + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds_GCJ='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + newsos6) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + hardcode_shlibpath_var_GCJ=no + ;; + + openbsd*) + hardcode_direct_GCJ=yes + hardcode_shlibpath_var_GCJ=no + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir' + export_dynamic_flag_spec_GCJ='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_GCJ='-R$libdir' + ;; + *) + archive_cmds_GCJ='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec_GCJ='${wl}-rpath,$libdir' + ;; + esac + fi + ;; + + os2*) + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_minus_L_GCJ=yes + allow_undefined_flag_GCJ=unsupported + archive_cmds_GCJ='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_From_new_cmds_GCJ='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag_GCJ=' -expect_unresolved \*' + archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + fi + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_GCJ=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag_GCJ=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_GCJ='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_GCJ='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag_GCJ=' -expect_unresolved \*' + archive_cmds_GCJ='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_GCJ='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ + $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec_GCJ='-rpath $libdir' + fi + hardcode_libdir_separator_GCJ=: + ;; + + sco3.2v5*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_GCJ=no + export_dynamic_flag_spec_GCJ='${wl}-Bexport' + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ;; + + solaris*) + no_undefined_flag_GCJ=' -z text' + if test "$GCC" = yes; then + archive_cmds_GCJ='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp' + else + archive_cmds_GCJ='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + fi + hardcode_libdir_flag_spec_GCJ='-R$libdir' + hardcode_shlibpath_var_GCJ=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_GCJ='-z allextract$convenience -z defaultextract' ;; + esac + link_all_deplibs_GCJ=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds_GCJ='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_GCJ='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_direct_GCJ=yes + hardcode_minus_L_GCJ=yes + hardcode_shlibpath_var_GCJ=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds_GCJ='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds_GCJ='$CC -r -o $output$reload_objs' + hardcode_direct_GCJ=no + ;; + motorola) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_GCJ=no + ;; + + sysv4.3*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_GCJ=no + export_dynamic_flag_spec_GCJ='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var_GCJ=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs_GCJ=yes + fi + ;; + + sysv4.2uw2*) + archive_cmds_GCJ='$LD -G -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct_GCJ=yes + hardcode_minus_L_GCJ=no + hardcode_shlibpath_var_GCJ=no + hardcode_runpath_var=yes + runpath_var=LD_RUN_PATH + ;; + + sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[78]* | unixware7*) + no_undefined_flag_GCJ='${wl}-z ${wl}text' + if test "$GCC" = yes; then + archive_cmds_GCJ='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds_GCJ='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var_GCJ=no + ;; + + sysv5*) + no_undefined_flag_GCJ=' -z text' + # $CC -shared without GNU ld will not create a library from C++ + # object files and a static libstdc++, better avoid it by now + archive_cmds_GCJ='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds_GCJ='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' + hardcode_libdir_flag_spec_GCJ= + hardcode_shlibpath_var_GCJ=no + runpath_var='LD_RUN_PATH' + ;; + + uts4*) + archive_cmds_GCJ='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec_GCJ='-L$libdir' + hardcode_shlibpath_var_GCJ=no + ;; + + *) + ld_shlibs_GCJ=no + ;; + esac + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_GCJ" >&5 +$as_echo "$ld_shlibs_GCJ" >&6; } +test "$ld_shlibs_GCJ" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_GCJ" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_GCJ=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_GCJ in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } + $rm conftest* + printf "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_GCJ + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_GCJ + allow_undefined_flag_GCJ= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_GCJ 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + archive_cmds_need_lc_GCJ=no + else + archive_cmds_need_lc_GCJ=yes + fi + allow_undefined_flag_GCJ=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $rm conftest* + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc_GCJ" >&5 +$as_echo "$archive_cmds_need_lc_GCJ" >&6; } + ;; + esac + fi + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix4* | aix5*) + version_type=linux + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi4*) + version_type=linux + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$host_os in + yes,cygwin* | yes,mingw* | yes,pw32*) + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $rm \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib" + ;; + mingw*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"` + if echo "$sys_lib_search_path_spec" | grep ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH printed by + # mingw gcc, but we are running on Cygwin. Gcc prints its search + # path with ; separators, and with drive letters. We can handle the + # drive letters (cygwin fileutils understands them), so leave them, + # especially as we might pass files found there to a mingw objdump, + # which wouldn't understand a cygwinified path. Ahh. + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/./-/g'`${versuffix}${shared_ext}' + ;; + esac + ;; + + *) + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + ;; + esac + dynamic_linker='Win32 ld.exe' + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)' + # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same. + if test "$GCC" = yes; then + sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"` + else + sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib' + fi + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd1*) + dynamic_linker=no + ;; + +kfreebsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +freebsd*) + objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.01* | freebsdelf3.01*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + *) # from 3.2 on + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + esac + ;; + +gnu*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case "$host_cpu" in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555. + postinstall_cmds='chmod 555 $lib' + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be Linux ELF. +linux*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + libsuff= + if test "$lt_cv_cc_lib64_suffix" = "yes"; then + libsuff=64 + fi + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`$SED -e 's/:,\t/ /g;s/=^=*$//;s/=^= * / /g' /etc/ld.so.conf | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} $lt_ld_extra" + sys_lib_search_path_spec="/lib${libsuff} /usr/lib${libsuff} /usr/X11R6/lib${libsuff} /usr/local/lib${libsuff} $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +knetbsd*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='GNU ld.so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +nto-qnx*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +openbsd*) + version_type=sunos + need_lib_prefix=no + need_version=yes + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +sco3.2v5*) + version_type=osf + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + ;; + +solaris*) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + export_dynamic_flag_spec='${wl}-Blargedynsym' + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +uts4*) + version_type=linux + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_GCJ= +if test -n "$hardcode_libdir_flag_spec_GCJ" || \ + test -n "$runpath_var GCJ" || \ + test "X$hardcode_automatic_GCJ"="Xyes" ; then + + # We can hardcode non-existant directories. + if test "$hardcode_direct_GCJ" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, GCJ)" != no && + test "$hardcode_minus_L_GCJ" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_GCJ=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_GCJ=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_GCJ=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_GCJ" >&5 +$as_echo "$hardcode_action_GCJ" >&6; } + +if test "$hardcode_action_GCJ" = relink; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + LDFLAGS="$LDFLAGS $link_static_flag" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext < +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" void exit (int); +#endif + +void fnord() { int i=42;} +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + /* dlclose (self); */ + } + + exit (status); +} +EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_GCJ \ + CC_GCJ \ + LD_GCJ \ + lt_prog_compiler_wl_GCJ \ + lt_prog_compiler_pic_GCJ \ + lt_prog_compiler_static_GCJ \ + lt_prog_compiler_no_builtin_flag_GCJ \ + export_dynamic_flag_spec_GCJ \ + thread_safe_flag_spec_GCJ \ + whole_archive_flag_spec_GCJ \ + enable_shared_with_static_runtimes_GCJ \ + old_archive_cmds_GCJ \ + old_archive_from_new_cmds_GCJ \ + predep_objects_GCJ \ + postdep_objects_GCJ \ + predeps_GCJ \ + postdeps_GCJ \ + compiler_lib_search_path_GCJ \ + archive_cmds_GCJ \ + archive_expsym_cmds_GCJ \ + postinstall_cmds_GCJ \ + postuninstall_cmds_GCJ \ + old_archive_from_expsyms_cmds_GCJ \ + allow_undefined_flag_GCJ \ + no_undefined_flag_GCJ \ + export_symbols_cmds_GCJ \ + hardcode_libdir_flag_spec_GCJ \ + hardcode_libdir_flag_spec_ld_GCJ \ + hardcode_libdir_separator_GCJ \ + hardcode_automatic_GCJ \ + module_cmds_GCJ \ + module_expsym_cmds_GCJ \ + lt_cv_prog_compiler_c_o_GCJ \ + exclude_expsyms_GCJ \ + include_expsyms_GCJ; do + + case $var in + old_archive_cmds_GCJ | \ + old_archive_from_new_cmds_GCJ | \ + archive_cmds_GCJ | \ + archive_expsym_cmds_GCJ | \ + module_cmds_GCJ | \ + module_expsym_cmds_GCJ | \ + old_archive_from_expsyms_cmds_GCJ | \ + export_symbols_cmds_GCJ | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_GCJ + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_GCJ + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_GCJ + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_GCJ + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_GCJ + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_GCJ + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_GCJ +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_GCJ + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_GCJ + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_GCJ + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_GCJ + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_GCJ + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_GCJ + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_GCJ +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_GCJ + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_GCJ + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_GCJ +archive_expsym_cmds=$lt_archive_expsym_cmds_GCJ +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_GCJ +module_expsym_cmds=$lt_module_expsym_cmds_GCJ + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_GCJ + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_GCJ + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_GCJ + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_GCJ + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_GCJ + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_GCJ + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_GCJ + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_GCJ + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_GCJ + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_GCJ + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_GCJ + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_GCJ + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_GCJ + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_GCJ + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_GCJ + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_GCJ + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_GCJ" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_GCJ + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_GCJ + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_GCJ + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_GCJ + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + else + tagname="" + fi + ;; + + RC) + + +# Source file extension for RC test sources. +ac_ext=rc + +# Object file extension for compiled RC test sources. +objext=o +objext_RC=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n' + +# Code to be used in simple link tests +lt_simple_link_test_code="$lt_simple_compile_test_code" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +CC=${RC-"windres"} +compiler=$CC +compiler_RC=$CC +lt_cv_prog_compiler_c_o_RC=yes + +# The else clause should only fire when bootstrapping the +# libtool distribution, otherwise you forgot to ship ltmain.sh +# with your package, and you will get complaints that there are +# no rules to generate ltmain.sh. +if test -f "$ltmain"; then + # See if we are running on zsh, and set the options which allow our commands through + # without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + # Now quote all the things that may contain metacharacters while being + # careful not to overquote the AC_SUBSTed values. We take copies of the + # variables and quote the copies for generation of the libtool script. + for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM \ + SED SHELL STRIP \ + libname_spec library_names_spec soname_spec extract_expsyms_cmds \ + old_striplib striplib file_magic_cmd finish_cmds finish_eval \ + deplibs_check_method reload_flag reload_cmds need_locks \ + lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl \ + lt_cv_sys_global_symbol_to_c_name_address \ + sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ + old_postinstall_cmds old_postuninstall_cmds \ + compiler_RC \ + CC_RC \ + LD_RC \ + lt_prog_compiler_wl_RC \ + lt_prog_compiler_pic_RC \ + lt_prog_compiler_static_RC \ + lt_prog_compiler_no_builtin_flag_RC \ + export_dynamic_flag_spec_RC \ + thread_safe_flag_spec_RC \ + whole_archive_flag_spec_RC \ + enable_shared_with_static_runtimes_RC \ + old_archive_cmds_RC \ + old_archive_from_new_cmds_RC \ + predep_objects_RC \ + postdep_objects_RC \ + predeps_RC \ + postdeps_RC \ + compiler_lib_search_path_RC \ + archive_cmds_RC \ + archive_expsym_cmds_RC \ + postinstall_cmds_RC \ + postuninstall_cmds_RC \ + old_archive_from_expsyms_cmds_RC \ + allow_undefined_flag_RC \ + no_undefined_flag_RC \ + export_symbols_cmds_RC \ + hardcode_libdir_flag_spec_RC \ + hardcode_libdir_flag_spec_ld_RC \ + hardcode_libdir_separator_RC \ + hardcode_automatic_RC \ + module_cmds_RC \ + module_expsym_cmds_RC \ + lt_cv_prog_compiler_c_o_RC \ + exclude_expsyms_RC \ + include_expsyms_RC; do + + case $var in + old_archive_cmds_RC | \ + old_archive_from_new_cmds_RC | \ + archive_cmds_RC | \ + archive_expsym_cmds_RC | \ + module_cmds_RC | \ + module_expsym_cmds_RC | \ + old_archive_from_expsyms_cmds_RC | \ + export_symbols_cmds_RC | \ + extract_expsyms_cmds | reload_cmds | finish_cmds | \ + postinstall_cmds | postuninstall_cmds | \ + old_postinstall_cmds | old_postuninstall_cmds | \ + sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) + # Double-quote double-evaled strings. + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" + ;; + esac + done + + case $lt_echo in + *'\$0 --fallback-echo"') + lt_echo=`$echo "X$lt_echo" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'` + ;; + esac + +cfgfile="$ofile" + + cat <<__EOF__ >> "$cfgfile" +# ### BEGIN LIBTOOL TAG CONFIG: $tagname + +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_RC + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_RC + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# The host system. +host_alias=$host_alias +host=$host + +# An echo program that does not interpret backslashes. +echo=$lt_echo + +# The archiver. +AR=$lt_AR +AR_FLAGS=$lt_AR_FLAGS + +# A C compiler. +LTCC=$lt_LTCC + +# A language-specific compiler. +CC=$lt_compiler_RC + +# Is the compiler the GNU C compiler? +with_gcc=$GCC_RC + +# An ERE matcher. +EGREP=$lt_EGREP + +# The linker used to build libraries. +LD=$lt_LD_RC + +# Whether we need hard or soft links. +LN_S=$lt_LN_S + +# A BSD-compatible nm program. +NM=$lt_NM + +# A symbol stripping program +STRIP=$lt_STRIP + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=$MAGIC_CMD + +# Used on cygwin: DLL creation program. +DLLTOOL="$DLLTOOL" + +# Used on cygwin: object dumper. +OBJDUMP="$OBJDUMP" + +# Used on cygwin: assembler. +AS="$AS" + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_RC + +# Object file suffix (normally "o"). +objext="$ac_objext" + +# Old archive suffix (normally "a"). +libext="$libext" + +# Shared library suffix (normally ".so"). +shrext_cmds='$shrext_cmds' + +# Executable file suffix (normally ""). +exeext="$exeext" + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_RC +pic_mode=$pic_mode + +# What is the maximum length of a command? +max_cmd_len=$lt_cv_sys_max_cmd_len + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_RC + +# Must we lock files when doing compilation ? +need_locks=$lt_need_locks + +# Do we need the lib prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_RC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_RC + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_RC + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_RC + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec=$lt_thread_safe_flag_spec_RC + +# Library versioning type. +version_type=$version_type + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Commands used to build and install an old-style archive. +RANLIB=$lt_RANLIB +old_archive_cmds=$lt_old_archive_cmds_RC +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_RC + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_RC + +# Commands used to build and install a shared archive. +archive_cmds=$lt_archive_cmds_RC +archive_expsym_cmds=$lt_archive_expsym_cmds_RC +postinstall_cmds=$lt_postinstall_cmds +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds=$lt_module_cmds_RC +module_expsym_cmds=$lt_module_expsym_cmds_RC + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects=$lt_predep_objects_RC + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects=$lt_postdep_objects_RC + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps=$lt_predeps_RC + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps=$lt_postdeps_RC + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_RC + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd=$lt_file_magic_cmd + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_RC + +# Flag that forces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_RC + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval=$lt_finish_eval + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# This is the shared library runtime path variable. +runpath_var=$runpath_var + +# This is the shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_RC + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist. +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_RC + +# If ld is used when linking, flag to hardcode \$libdir into +# a binary during linking. This must work even if \$libdir does +# not exist. +hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld_RC + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_RC + +# Set to yes if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=$hardcode_direct_RC + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=$hardcode_minus_L_RC + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_RC + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=$hardcode_automatic_RC + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="$variables_saved_for_relink" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_RC + +# Compile-time system search path for libraries +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Fix the shell variable \$srcfile for the compiler. +fix_srcfile_path="$fix_srcfile_path_RC" + +# Set to yes if exported symbols are required. +always_export_symbols=$always_export_symbols_RC + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_RC + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_RC + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_RC + +# ### END LIBTOOL TAG CONFIG: $tagname + +__EOF__ + + +else + # If there is no Makefile yet, we rely on a make rule to execute + # `config.status --recheck' to rerun these tests and create the + # libtool script then. + ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'` + if test -f "$ltmain_in"; then + test -f Makefile && make "$ltmain" + fi +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + ;; + + *) + as_fn_error $? "Unsupported tag name: $tagname" "$LINENO" 5 + ;; + esac + + # Append the new tag name to the list of available tags. + if test -n "$tagname" ; then + available_tags="$available_tags $tagname" + fi + fi + done + IFS="$lt_save_ifs" + + # Now substitute the updated list of available tags. + if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then + mv "${ofile}T" "$ofile" + chmod +x "$ofile" + else + rm -f "${ofile}T" + as_fn_error $? "unable to update list of available tagged configurations." "$LINENO" 5 + fi +fi + + + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' + +# Prevent multiple expansion + + + + + + + + + + + + + + + + + + + + + +# Check whether --enable-swap-count was given. +if test "${enable_swap_count+set}" = set; then : + enableval=$enable_swap_count; +fi + +case $enable_swap_count in + yes) + +$as_echo "#define SWAPCOUNT 1" >>confdefs.h + + ;; +esac + +# Check whether --enable-cache-stats was given. +if test "${enable_cache_stats+set}" = set; then : + enableval=$enable_cache_stats; +fi + +case $enable_cache_stats in + yes) + +$as_echo "#define CACHESTATS 1" >>confdefs.h + + ;; +esac + + +ac_config_headers="$ac_config_headers config.h" + + +ac_config_files="$ac_config_files Makefile src/Makefile" + + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + +if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then + as_fn_error $? "conditional \"AMDEP\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCC\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by buddy $as_me 2.4, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" +config_headers="$ac_config_headers" +config_commands="$ac_config_commands" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Configuration commands: +$config_commands + +Report bugs to the package provider." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +buddy config.status 2.4 +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +INSTALL='$INSTALL' +AWK='$AWK' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# +# INIT-COMMANDS +# +AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; + "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; + "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers + test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + + case $INSTALL in + [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; + esac +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +s&@INSTALL@&$ac_INSTALL&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi +# Compute "$ac_file"'s index in $config_headers. +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + "$ac_file" | "$ac_file":* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for "$ac_file"" >`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'`/stamp-h$_am_stamp_count + ;; + + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +$as_echo "$as_me: executing $ac_file commands" >&6;} + ;; + esac + + + case $ac_file$ac_mode in + "depfiles":C) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named `Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # So let's grep whole file. + if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then + dirpart=`$as_dirname -- "$mf" || +$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$mf" : 'X\(//\)[^/]' \| \ + X"$mf" : 'X\(//\)$' \| \ + X"$mf" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$mf" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + else + continue + fi + grep '^DEP_FILES *= *[^ #]' < "$mf" > /dev/null || continue + # Extract the definition of DEP_FILES from the Makefile without + # running `make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + # When using ansi2knr, U may be empty or an underscore; expand it + U=`sed -n 's/^U = //p' < "$mf"` + test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR" + # We invoke sed twice because it is the simplest approach to + # changing $(DEPDIR) to its actual value in the expansion. + for file in `sed -n ' + /^DEP_FILES = .*\\\\$/ { + s/^DEP_FILES = // + :loop + s/\\\\$// + p + n + /\\\\$/ b loop + p + } + /^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`$as_dirname -- "$file" || +$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$file" : 'X\(//\)[^/]' \| \ + X"$file" : 'X\(//\)$' \| \ + X"$file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir=$dirpart/$fdir; as_fn_mkdir_p + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done +done + ;; + + esac +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + diff --git a/sdk/buddy-2.4/configure.ac b/sdk/buddy-2.4/configure.ac new file mode 100644 index 0000000..edb4669 --- /dev/null +++ b/sdk/buddy-2.4/configure.ac @@ -0,0 +1,29 @@ +AC_PREREQ([2.57]) +AC_INIT([buddy], [2.4]) +AC_CONFIG_AUX_DIR([tools]) +AM_INIT_AUTOMAKE([foreign nostdinc no-define 1.7.3]) + +MAJOR_VERSION=`echo "$VERSION" | sed -e 's/^\([[0-9]]*\)\.[[0-9]]*.*$/\1/'` +MINOR_VERSION=`echo "$VERSION" | sed -e 's/^[[0-9]]*\.\([[0-9]]*\).*$/\1/'` +AC_DEFINE_UNQUOTED([MAJOR_VERSION], [$MAJOR_VERSION], [BuDDy's major version.]) +AC_DEFINE_UNQUOTED([MINOR_VERSION], [$MINOR_VERSION], [BuDDy's minor version.]) + +AC_PROG_CC + +dnl AM_PROG_LEX +dnl AC_PROG_YACC + +AC_PROG_CXX + +AC_PROG_LIBTOOL + +buddy_DEBUG_FLAGS + +AC_CONFIG_HEADERS([config.h]) + +AC_CONFIG_FILES([ + Makefile + src/Makefile +]) + +AC_OUTPUT diff --git a/sdk/buddy-2.4/include/bdd.h b/sdk/buddy-2.4/include/bdd.h new file mode 100644 index 0000000..6f55d7a --- /dev/null +++ b/sdk/buddy-2.4/include/bdd.h @@ -0,0 +1,838 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bdd.h,v 1.1.1.1 2004/06/25 13:22:09 haimcohen Exp $ + FILE: bdd.h + DESCR: C,C++ User interface for the BDD package + AUTH: Jorn Lind + DATE: (C) feb 1997 +*************************************************************************/ + +#ifndef _BDD_H +#define _BDD_H + + /* Allow this headerfile to define C++ constructs if requested */ +#ifdef __cplusplus +#define CPLUSPLUS +#endif + +#include + +/*=== Defined operators for apply calls ================================*/ + +#define bddop_and 0 +#define bddop_xor 1 +#define bddop_or 2 +#define bddop_nand 3 +#define bddop_nor 4 +#define bddop_imp 5 +#define bddop_biimp 6 +#define bddop_diff 7 +#define bddop_less 8 +#define bddop_invimp 9 + + /* Should *not* be used in bdd_apply calls !!! */ +#define bddop_not 10 +#define bddop_simplify 11 + + +/*=== User BDD types ===================================================*/ + +typedef int BDD; + +#ifndef CPLUSPLUS +typedef BDD bdd; +#endif /* CPLUSPLUS */ + + +typedef struct s_bddPair +{ + BDD *result; + int last; + int id; + struct s_bddPair *next; +} bddPair; + + +/*=== Status information ===============================================*/ + +/* +NAME {* bddStat *} +SECTION {* kernel *} +SHORT {* Status information about the bdd package *} +PROTO {* typedef struct s_bddStat +{ + long int produced; + int nodenum; + int maxnodenum; + int freenodes; + int minfreenodes; + int varnum; + int cachesize; + int gbcnum; +} bddStat; *} +DESCR {* The fields are \\[\baselineskip] \begin{tabular}{lp{10cm}} + {\tt produced} & total number of new nodes ever produced \\ + {\tt nodenum} & currently allocated number of bdd nodes \\ + {\tt maxnodenum} & user defined maximum number of bdd nodes \\ + {\tt freenodes} & number of currently free nodes \\ + {\tt minfreenodes} & minimum number of nodes that should be left after a + garbage collection. \\ + {\tt varnum} & number of defined bdd variables \\ + {\tt cachesize} & number of entries in the internal caches \\ + {\tt gbcnum} & number of garbage collections done until now + \end{tabular} *} +ALSO {* bdd\_stats *} +*/ +typedef struct s_bddStat +{ + long int produced; + int nodenum; + int maxnodenum; + int freenodes; + int minfreenodes; + int varnum; + int cachesize; + int gbcnum; +} bddStat; + + +/* +NAME {* bddGbcStat *} +SECTION {* kernel *} +SHORT {* Status information about garbage collections *} +PROTO {* typedef struct s_bddGbcStat +{ + int nodes; + int freenodes; + long time; + long sumtime; + int num; +} bddGbcStat; *} +DESCR {* The fields are \\[\baselineskip] \begin{tabular}{ll} + {\tt nodes} & Total number of allocated nodes in the nodetable \\ + {\tt freenodes} & Number of free nodes in the nodetable \\ + {\tt time} & Time used for garbage collection this time \\ + {\tt sumtime} & Total time used for garbage collection \\ + {\tt num} & number of garbage collections done until now + \end{tabular} *} +ALSO {* bdd\_gbc\_hook *} +*/ +typedef struct s_bddGbcStat +{ + int nodes; + int freenodes; + long time; + long sumtime; + int num; +} bddGbcStat; + + +/* +NAME {* bddCacheStat *} +SECTION {* kernel *} +SHORT {* Status information about cache usage *} +PROTO {* typedef struct s_bddCacheStat +{ + long unsigned int uniqueAccess; + long unsigned int uniqueChain; + long unsigned int uniqueHit; + long unsigned int uniqueMiss; + long unsigned int opHit; + long unsigned int opMiss; + long unsigned int swapCount; +} bddCacheStat; *} +DESCR {* The fields are \\[\baselineskip] \begin{tabular}{ll} + {\bf Name} & {\bf Number of } \\ + uniqueAccess & accesses to the unique node table \\ + uniqueChain & iterations through the cache chains in the unique node table\\ + uniqueHit & entries actually found in the the unique node table \\ + uniqueMiss & entries not found in the the unique node table \\ + opHit & entries found in the operator caches \\ + opMiss & entries not found in the operator caches \\ + swapCount & number of variable swaps in reordering \\ +\end{tabular} *} +ALSO {* bdd\_cachestats *} +*/ +typedef struct s_bddCacheStat +{ + long unsigned int uniqueAccess; + long unsigned int uniqueChain; + long unsigned int uniqueHit; + long unsigned int uniqueMiss; + long unsigned int opHit; + long unsigned int opMiss; + long unsigned int swapCount; +} bddCacheStat; + +/*=== BDD interface prototypes =========================================*/ + +/* +NAME {* bdd\_relprod *} +SECTION {* operator *} +SHORT {* relational product *} +PROTO {* #define bdd_relprod(a,b,var) bdd_appex(a,b,bddop_and,var) *} +DESCR {* Calculates the relational product of {\tt a} and {\tt b} as + {\tt a AND b} with the variables in {\tt var} quantified out + afterwards. *} +RETURN {* The relational product or {\tt bddfalse} on errors. *} +ALSO {* bdd\_appex *} +*/ +#define bdd_relprod(a,b,var) bdd_appex((a),(b),bddop_and,(var)) + + + /* In file "kernel.c" */ + +#ifdef CPLUSPLUS +extern "C" { +#endif + +typedef void (*bddinthandler)(int); +typedef void (*bddgbchandler)(int,bddGbcStat*); +typedef void (*bdd2inthandler)(int,int); +typedef int (*bddsizehandler)(void); +typedef void (*bddfilehandler)(FILE *, int); +typedef void (*bddallsathandler)(char*, int); + +extern bddinthandler bdd_error_hook(bddinthandler); +extern bddgbchandler bdd_gbc_hook(bddgbchandler); +extern bdd2inthandler bdd_resize_hook(bdd2inthandler); +extern bddinthandler bdd_reorder_hook(bddinthandler); +extern bddfilehandler bdd_file_hook(bddfilehandler); + +extern int bdd_init(int, int); +extern void bdd_done(void); +extern int bdd_setvarnum(int); +extern int bdd_extvarnum(int); +extern int bdd_isrunning(void); +extern int bdd_setmaxnodenum(int); +extern int bdd_setmaxincrease(int); +extern int bdd_setminfreenodes(int); +extern int bdd_getnodenum(void); +extern int bdd_getallocnum(void); +extern char* bdd_versionstr(void); +extern int bdd_versionnum(void); +extern void bdd_stats(bddStat *); +extern void bdd_cachestats(bddCacheStat *); +extern void bdd_fprintstat(FILE *); +extern void bdd_printstat(void); +extern void bdd_default_gbchandler(int, bddGbcStat *); +extern void bdd_default_errhandler(int); +extern const char *bdd_errstring(int); +extern void bdd_clear_error(void); +#ifndef CPLUSPLUS +extern BDD bdd_true(void); +extern BDD bdd_false(void); +#endif +extern int bdd_varnum(void); +extern BDD bdd_ithvar(int); +extern BDD bdd_nithvar(int); +extern int bdd_var(BDD); +extern BDD bdd_low(BDD); +extern BDD bdd_high(BDD); +extern int bdd_varlevel(int); +extern BDD bdd_addref(BDD); +extern BDD bdd_delref(BDD); +extern void bdd_gbc(void); +extern int bdd_scanset(BDD, int**, int*); +extern BDD bdd_makeset(int *, int); +extern bddPair* bdd_newpair(void); +extern int bdd_setpair(bddPair*, int, int); +extern int bdd_setpairs(bddPair*, int*, int*, int); +extern int bdd_setbddpair(bddPair*, int, BDD); +extern int bdd_setbddpairs(bddPair*, int*, BDD*, int); +extern void bdd_resetpair(bddPair *); +extern void bdd_freepair(bddPair*); + + /* In bddop.c */ + +extern int bdd_setcacheratio(int); +extern BDD bdd_buildcube(int, int, BDD *); +extern BDD bdd_ibuildcube(int, int, int *); +extern BDD bdd_not(BDD); +extern BDD bdd_apply(BDD, BDD, int); +extern BDD bdd_and(BDD, BDD); +extern BDD bdd_or(BDD, BDD); +extern BDD bdd_xor(BDD, BDD); +extern BDD bdd_imp(BDD, BDD); +extern BDD bdd_biimp(BDD, BDD); +extern BDD bdd_ite(BDD, BDD, BDD); +extern BDD bdd_restrict(BDD, BDD); +extern BDD bdd_constrain(BDD, BDD); +extern BDD bdd_replace(BDD, bddPair*); +extern BDD bdd_compose(BDD, BDD, BDD); +extern BDD bdd_veccompose(BDD, bddPair*); +extern BDD bdd_simplify(BDD, BDD); +extern BDD bdd_exist(BDD, BDD); +extern BDD bdd_project(BDD, BDD); +extern BDD bdd_forall(BDD, BDD); +extern BDD bdd_unique(BDD, BDD); +extern BDD bdd_appex(BDD, BDD, int, BDD); +extern BDD bdd_appall(BDD, BDD, int, BDD); +extern BDD bdd_appuni(BDD, BDD, int, BDD); +extern BDD bdd_support(BDD); +extern BDD bdd_satone(BDD); +extern BDD bdd_satoneset(BDD, BDD, BDD); +extern BDD bdd_fullsatone(BDD); +extern void bdd_allsat(BDD r, bddallsathandler handler); +extern double bdd_satcount(BDD); +extern double bdd_satcountset(BDD, BDD); +extern double bdd_satcountln(BDD); +extern double bdd_satcountlnset(BDD, BDD); +extern int bdd_nodecount(BDD); +extern int bdd_anodecount(BDD *, int); +extern int* bdd_varprofile(BDD); +extern double bdd_pathcount(BDD); + + +/* In file "bddio.c" */ + +extern void bdd_printall(void); +extern void bdd_fprintall(FILE *); +extern void bdd_fprinttable(FILE *, BDD); +extern void bdd_printtable(BDD); +extern void bdd_fprintset(FILE *, BDD); +extern void bdd_printset(BDD); +extern int bdd_fnprintdot(char *, BDD); +extern void bdd_fprintdot(FILE *, BDD); +extern void bdd_printdot(BDD); +extern int bdd_fnsave(char *, BDD); +extern int bdd_save(FILE *, BDD); +extern int bdd_fnload(char *, BDD *); +extern int bdd_load(FILE *ifile, BDD *); + +/* In file reorder.c */ + +extern int bdd_swapvar(int v1, int v2); +extern void bdd_default_reohandler(int); +extern void bdd_reorder(int); +extern int bdd_reorder_gain(void); +extern bddsizehandler bdd_reorder_probe(bddsizehandler); +extern void bdd_clrvarblocks(void); +extern int bdd_addvarblock(BDD, int); +extern int bdd_intaddvarblock(int, int, int); +extern void bdd_varblockall(void); +extern bddfilehandler bdd_blockfile_hook(bddfilehandler); +extern int bdd_autoreorder(int); +extern int bdd_autoreorder_times(int, int); +extern int bdd_var2level(int); +extern int bdd_level2var(int); +extern int bdd_getreorder_times(void); +extern int bdd_getreorder_method(void); +extern void bdd_enable_reorder(void); +extern void bdd_disable_reorder(void); +extern int bdd_reorder_verbose(int); +extern void bdd_setvarorder(int *); +extern void bdd_printorder(void); +extern void bdd_fprintorder(FILE *); + +#ifdef CPLUSPLUS +} +#endif + + +/*=== BDD constants ====================================================*/ + +#ifndef CPLUSPLUS + +extern const BDD bddfalse; +extern const BDD bddtrue; + +#endif /* CPLUSPLUS */ + + +/*=== Reordering algorithms ============================================*/ + +#define BDD_REORDER_NONE 0 +#define BDD_REORDER_WIN2 1 +#define BDD_REORDER_WIN2ITE 2 +#define BDD_REORDER_SIFT 3 +#define BDD_REORDER_SIFTITE 4 +#define BDD_REORDER_WIN3 5 +#define BDD_REORDER_WIN3ITE 6 +#define BDD_REORDER_RANDOM 7 + +#define BDD_REORDER_FREE 0 +#define BDD_REORDER_FIXED 1 + + +/*=== Error codes ======================================================*/ + +#define BDD_MEMORY (-1) /* Out of memory */ +#define BDD_VAR (-2) /* Unknown variable */ +#define BDD_RANGE (-3) /* Variable value out of range (not in domain) */ +#define BDD_DEREF (-4) /* Removing external reference to unknown node */ +#define BDD_RUNNING (-5) /* Called bdd_init() twice whithout bdd_done() */ +#define BDD_FILE (-6) /* Some file operation failed */ +#define BDD_FORMAT (-7) /* Incorrect file format */ +#define BDD_ORDER (-8) /* Vars. not in order for vector based functions */ +#define BDD_BREAK (-9) /* User called break */ +#define BDD_VARNUM (-10) /* Different number of vars. for vector pair */ +#define BDD_NODES (-11) /* Tried to set max. number of nodes to be fewer */ + /* than there already has been allocated */ +#define BDD_OP (-12) /* Unknown operator */ +#define BDD_VARSET (-13) /* Illegal variable set */ +#define BDD_VARBLK (-14) /* Bad variable block operation */ +#define BDD_DECVNUM (-15) /* Trying to decrease the number of variables */ +#define BDD_REPLACE (-16) /* Replacing to already existing variables */ +#define BDD_NODENUM (-17) /* Number of nodes reached user defined maximum */ +#define BDD_ILLBDD (-18) /* Illegal bdd argument */ +#define BDD_SIZE (-19) /* Illegal size argument */ + +#define BVEC_SIZE (-20) /* Mismatch in bitvector size */ +#define BVEC_SHIFT (-21) /* Illegal shift-left/right parameter */ +#define BVEC_DIVZERO (-22) /* Division by zero */ + +#define BDD_ERRNUM 24 + +/************************************************************************* + If this file is included from a C++ compiler then the following + classes, wrappers and hacks are supplied. +*************************************************************************/ +#ifdef CPLUSPLUS +#include + +/*=== User BDD class ===================================================*/ + +class bvec; + +class bdd +{ + public: + + bdd(void) { root=0; } + bdd(const bdd &r) { bdd_addref(root=r.root); } + ~bdd(void) { bdd_delref(root); } + + int id(void) const; + + bdd operator=(const bdd &r); + + bdd operator&(const bdd &r) const; + bdd operator&=(const bdd &r); + bdd operator^(const bdd &r) const; + bdd operator^=(const bdd &r); + bdd operator|(const bdd &r) const; + bdd operator|=(const bdd &r); + bdd operator!(void) const; + bdd operator>>(const bdd &r) const; + bdd operator>>=(const bdd &r); + bdd operator-(const bdd &r) const; + bdd operator-=(const bdd &r); + bdd operator>(const bdd &r) const; + bdd operator<(const bdd &r) const; + bdd operator<<(const bdd &r) const; + bdd operator<<=(const bdd &r); + int operator==(const bdd &r) const; + int operator!=(const bdd &r) const; + +private: + BDD root; + + bdd(BDD r) { bdd_addref(root=r); } + bdd operator=(BDD r); + + friend int bdd_init(int, int); + friend int bdd_setvarnum(int); + friend bdd bdd_true(void); + friend bdd bdd_false(void); + friend bdd bdd_ithvarpp(int); + friend bdd bdd_nithvarpp(int); + friend int bdd_var(const bdd &); + friend bdd bdd_low(const bdd &); + friend bdd bdd_high(const bdd &); + friend int bdd_scanset(const bdd &, int *&, int &); + friend bdd bdd_makesetpp(int *, int); + friend int bdd_setbddpair(bddPair*, int, const bdd &); + friend int bdd_setbddpairs(bddPair*, int*, const bdd *, int); + friend bdd bdd_buildcube(int, int, const bdd *); + friend bdd bdd_ibuildcubepp(int, int, int *); + friend bdd bdd_not(const bdd &); + friend bdd bdd_simplify(const bdd &, const bdd &); + friend bdd bdd_apply(const bdd &, const bdd &, int); + friend bdd bdd_and(const bdd &, const bdd &); + friend bdd bdd_or(const bdd &, const bdd &); + friend bdd bdd_xor(const bdd &, const bdd &); + friend bdd bdd_imp(const bdd &, const bdd &); + friend bdd bdd_biimp(const bdd &, const bdd &); + friend bdd bdd_ite(const bdd &, const bdd &, const bdd &); + friend bdd bdd_restrict(const bdd &, const bdd &); + friend bdd bdd_constrain(const bdd &, const bdd &); + friend bdd bdd_exist(const bdd &, const bdd &); + friend bdd bdd_project(const bdd &, const bdd &); + friend bdd bdd_forall(const bdd &, const bdd &); + friend bdd bdd_unique(const bdd &, const bdd &); + friend bdd bdd_appex(const bdd &, const bdd &, int, const bdd &); + friend bdd bdd_appall(const bdd &, const bdd &, int, const bdd &); + friend bdd bdd_appuni(const bdd &, const bdd &, int, const bdd &); + friend bdd bdd_replace(const bdd &, bddPair*); + friend bdd bdd_compose(const bdd &, const bdd &, int); + friend bdd bdd_veccompose(const bdd &, bddPair*); + friend bdd bdd_support(const bdd &); + friend bdd bdd_satone(const bdd &); + friend bdd bdd_satoneset(const bdd &, const bdd &, const bdd &); + friend bdd bdd_fullsatone(const bdd &); + friend void bdd_allsat(const bdd &r, bddallsathandler handler); + friend double bdd_satcount(const bdd &); + friend double bdd_satcountset(const bdd &, const bdd &); + friend double bdd_satcountln(const bdd &); + friend double bdd_satcountlnset(const bdd &, const bdd &); + friend int bdd_nodecount(const bdd &); + friend int bdd_anodecountpp(const bdd *, int); + friend int* bdd_varprofile(const bdd &); + friend double bdd_pathcount(const bdd &); + + friend void bdd_fprinttable(FILE *, const bdd &); + friend void bdd_printtable(const bdd &); + friend void bdd_fprintset(FILE *, const bdd &); + friend void bdd_printset(const bdd &); + friend void bdd_printdot(const bdd &); + friend int bdd_fnprintdot(char*, const bdd &); + friend void bdd_fprintdot(FILE*, const bdd &); + friend std::ostream &operator<<(std::ostream &, const bdd &); + friend int bdd_fnsave(char*, const bdd &); + friend int bdd_save(FILE*, const bdd &); + friend int bdd_fnload(char*, bdd &); + friend int bdd_load(FILE*, bdd &); + + friend bdd fdd_ithvarpp(int, int); + friend bdd fdd_ithsetpp(int); + friend bdd fdd_domainpp(int); + friend int fdd_scanvar(const bdd &, int); + friend int* fdd_scanallvar(const bdd &); + friend bdd fdd_equalspp(int, int); + friend void fdd_printset(const bdd &); + friend void fdd_fprintset(FILE*, const bdd &); + friend bdd fdd_makesetpp(int*, int); + friend int fdd_scanset(const bdd &, int *&, int &); + + friend int bdd_addvarblock(const bdd &, int); + + friend class bvec; + friend bvec bvec_ite(const bdd& a, const bvec& b, const bvec& c); + friend bvec bvec_shlfixed(const bvec &e, int pos, const bdd &c); + friend bvec bvec_shl(const bvec &left, const bvec &right, const bdd &c); + friend bvec bvec_shrfixed(const bvec &e, int pos, const bdd &c); + friend bvec bvec_shr(const bvec &left, const bvec &right, const bdd &c); + friend bdd bvec_lth(const bvec &left, const bvec &right); + friend bdd bvec_lte(const bvec &left, const bvec &right); + friend bdd bvec_gth(const bvec &left, const bvec &right); + friend bdd bvec_gte(const bvec &left, const bvec &right); + friend bdd bvec_equ(const bvec &left, const bvec &right); + friend bdd bvec_neq(const bvec &left, const bvec &right); +}; + + +/*=== BDD constants ====================================================*/ + +extern const bdd bddfalsepp; +extern const bdd bddtruepp; + +#define bddtrue bddtruepp +#define bddfalse bddfalsepp + +/*=== C++ interface ====================================================*/ + +extern int bdd_cpp_init(int, int); + +inline void bdd_stats(bddStat& s) +{ bdd_stats(&s); } + +inline bdd bdd_ithvarpp(int v) +{ return bdd_ithvar(v); } + +inline bdd bdd_nithvarpp(int v) +{ return bdd_nithvar(v); } + +inline int bdd_var(const bdd &r) +{ return bdd_var(r.root); } + +inline bdd bdd_low(const bdd &r) +{ return bdd_low(r.root); } + +inline bdd bdd_high(const bdd &r) +{ return bdd_high(r.root); } + +inline int bdd_scanset(const bdd &r, int *&v, int &n) +{ return bdd_scanset(r.root, &v, &n); } + +inline bdd bdd_makesetpp(int *v, int n) +{ return bdd(bdd_makeset(v,n)); } + +inline int bdd_setbddpair(bddPair *p, int ov, const bdd &nv) +{ return bdd_setbddpair(p,ov,nv.root); } + + /* In bddop.c */ + +inline bdd bdd_replace(const bdd &r, bddPair *p) +{ return bdd_replace(r.root, p); } + +inline bdd bdd_compose(const bdd &f, const bdd &g, int v) +{ return bdd_compose(f.root, g.root, v); } + +inline bdd bdd_veccompose(const bdd &f, bddPair *p) +{ return bdd_veccompose(f.root, p); } + +inline bdd bdd_restrict(const bdd &r, const bdd &var) +{ return bdd_restrict(r.root, var.root); } + +inline bdd bdd_constrain(const bdd &f, const bdd &c) +{ return bdd_constrain(f.root, c.root); } + +inline bdd bdd_simplify(const bdd &d, const bdd &b) +{ return bdd_simplify(d.root, b.root); } + +inline bdd bdd_ibuildcubepp(int v, int w, int *a) +{ return bdd_ibuildcube(v,w,a); } + +inline bdd bdd_not(const bdd &r) +{ return bdd_not(r.root); } + +inline bdd bdd_apply(const bdd &l, const bdd &r, int op) +{ return bdd_apply(l.root, r.root, op); } + +inline bdd bdd_and(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_and); } + +inline bdd bdd_or(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_or); } + +inline bdd bdd_xor(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_xor); } + +inline bdd bdd_imp(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_imp); } + +inline bdd bdd_biimp(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_biimp); } + +inline bdd bdd_ite(const bdd &f, const bdd &g, const bdd &h) +{ return bdd_ite(f.root, g.root, h.root); } + +inline bdd bdd_exist(const bdd &r, const bdd &var) +{ return bdd_exist(r.root, var.root); } + +inline bdd bdd_project(const bdd &r, const bdd &var) +{ return bdd_project(r.root, var.root); } + +inline bdd bdd_forall(const bdd &r, const bdd &var) +{ return bdd_forall(r.root, var.root); } + +inline bdd bdd_unique(const bdd &r, const bdd &var) +{ return bdd_unique(r.root, var.root); } + +inline bdd bdd_appex(const bdd &l, const bdd &r, int op, const bdd &var) +{ return bdd_appex(l.root, r.root, op, var.root); } + +inline bdd bdd_appall(const bdd &l, const bdd &r, int op, const bdd &var) +{ return bdd_appall(l.root, r.root, op, var.root); } + +inline bdd bdd_appuni(const bdd &l, const bdd &r, int op, const bdd &var) +{ return bdd_appuni(l.root, r.root, op, var.root); } + +inline bdd bdd_support(const bdd &r) +{ return bdd_support(r.root); } + +inline bdd bdd_satone(const bdd &r) +{ return bdd_satone(r.root); } + +inline bdd bdd_satoneset(const bdd &r, const bdd &var, const bdd &pol) +{ return bdd_satoneset(r.root, var.root, pol.root); } + +inline bdd bdd_fullsatone(const bdd &r) +{ return bdd_fullsatone(r.root); } + +inline void bdd_allsat(const bdd &r, bddallsathandler handler) +{ bdd_allsat(r.root, handler); } + +inline double bdd_satcount(const bdd &r) +{ return bdd_satcount(r.root); } + +inline double bdd_satcountset(const bdd &r, const bdd &varset) +{ return bdd_satcountset(r.root, varset.root); } + +inline double bdd_satcountln(const bdd &r) +{ return bdd_satcountln(r.root); } + +inline double bdd_satcountlnset(const bdd &r, const bdd &varset) +{ return bdd_satcountlnset(r.root, varset.root); } + +inline int bdd_nodecount(const bdd &r) +{ return bdd_nodecount(r.root); } + +inline int* bdd_varprofile(const bdd &r) +{ return bdd_varprofile(r.root); } + +inline double bdd_pathcount(const bdd &r) +{ return bdd_pathcount(r.root); } + + + /* I/O extensions */ + +inline void bdd_fprinttable(FILE *file, const bdd &r) +{ bdd_fprinttable(file, r.root); } + +inline void bdd_printtable(const bdd &r) +{ bdd_printtable(r.root); } + +inline void bdd_fprintset(FILE *file, const bdd &r) +{ bdd_fprintset(file, r.root); } + +inline void bdd_printset(const bdd &r) +{ bdd_printset(r.root); } + +inline void bdd_printdot(const bdd &r) +{ bdd_printdot(r.root); } + +inline void bdd_fprintdot(FILE* ofile, const bdd &r) +{ bdd_fprintdot(ofile, r.root); } + +inline int bdd_fnprintdot(char* fname, const bdd &r) +{ return bdd_fnprintdot(fname, r.root); } + +inline int bdd_fnsave(char *fname, const bdd &r) +{ return bdd_fnsave(fname, r.root); } + +inline int bdd_save(FILE *ofile, const bdd &r) +{ return bdd_save(ofile, r.root); } + +inline int bdd_fnload(char *fname, bdd &r) +{ int lr,e; e=bdd_fnload(fname, &lr); r=bdd(lr); return e; } + +inline int bdd_load(FILE *ifile, bdd &r) +{ int lr,e; e=bdd_load(ifile, &lr); r=bdd(lr); return e; } + +inline int bdd_addvarblock(const bdd &v, int f) +{ return bdd_addvarblock(v.root, f); } + + /* Hack to allow for overloading */ +#define bdd_init bdd_cpp_init +#define bdd_ithvar bdd_ithvarpp +#define bdd_nithvar bdd_nithvarpp +#define bdd_makeset bdd_makesetpp +#define bdd_ibuildcube bdd_ibuildcubepp +#define bdd_anodecount bdd_anodecountpp + +/*=== Inline C++ functions =============================================*/ + +inline int bdd::id(void) const +{ return root; } + +inline bdd bdd::operator&(const bdd &r) const +{ return bdd_apply(*this,r,bddop_and); } + +inline bdd bdd::operator&=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_and)); } + +inline bdd bdd::operator^(const bdd &r) const +{ return bdd_apply(*this,r,bddop_xor); } + +inline bdd bdd::operator^=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_xor)); } + +inline bdd bdd::operator|(const bdd &r) const +{ return bdd_apply(*this,r,bddop_or); } + +inline bdd bdd::operator|=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_or)); } + +inline bdd bdd::operator!(void) const +{ return bdd_not(*this);} + +inline bdd bdd::operator>>(const bdd &r) const +{ return bdd_apply(*this,r,bddop_imp); } + +inline bdd bdd::operator>>=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_imp)); } + +inline bdd bdd::operator-(const bdd &r) const +{ return bdd_apply(*this,r,bddop_diff); } + +inline bdd bdd::operator-=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_diff)); } + +inline bdd bdd::operator>(const bdd &r) const +{ return bdd_apply(*this,r,bddop_diff); } + +inline bdd bdd::operator<(const bdd &r) const +{ return bdd_apply(*this,r,bddop_less); } + +inline bdd bdd::operator<<(const bdd &r) const +{ return bdd_apply(*this,r,bddop_invimp); } + +inline bdd bdd::operator<<=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_invimp)); } + +inline int bdd::operator==(const bdd &r) const +{ return r.root==root; } + +inline int bdd::operator!=(const bdd &r) const +{ return r.root!=root; } + +inline bdd bdd_true(void) +{ return 1; } + +inline bdd bdd_false(void) +{ return 0; } + + +/*=== Iostream printing ================================================*/ + +class bdd_ioformat +{ + public: + bdd_ioformat(int f) { format=f; } + private: + bdd_ioformat(void) { } + int format; + static int curformat; + + friend std::ostream &operator<<(std::ostream &, const bdd_ioformat &); + friend std::ostream &operator<<(std::ostream &, const bdd &); +}; + +std::ostream &operator<<(std::ostream &, const bdd &); +std::ostream &operator<<(std::ostream &, const bdd_ioformat &); + +extern bdd_ioformat bddset; +extern bdd_ioformat bddtable; +extern bdd_ioformat bdddot; +extern bdd_ioformat bddall; +extern bdd_ioformat fddset; + +typedef void (*bddstrmhandler)(std::ostream &, int); + +extern bddstrmhandler bdd_strm_hook(bddstrmhandler); + +#endif /* CPLUSPLUS */ + +#endif /* _BDD_H */ + +/* EOF */ diff --git a/sdk/buddy-2.4/include/bvec.h b/sdk/buddy-2.4/include/bvec.h new file mode 100644 index 0000000..326a2b2 --- /dev/null +++ b/sdk/buddy-2.4/include/bvec.h @@ -0,0 +1,297 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bvec.h,v 1.1.1.1 2004/06/25 13:22:34 haimcohen Exp $ + FILE: bvec.h + DESCR: Boolean (BDD) vector handling + AUTH: Jorn Lind + DATE: (C) may 1999 +*************************************************************************/ + +#ifndef _BVEC_H +#define _BVEC_H + +#include "fdd.h" + + /* Boolean (BDD) vector */ +/* +NAME {* bvec *} +SECTION {* bvec *} +SHORT {* A boolean vector *} +PROTO {* typedef struct s_bvec +{ + int bitnum; + BDD *bitvec; +} BVEC; + +typedef BVEC bvec; *} +DESCR {* This data structure is used to store boolean vectors. The field + {\tt bitnum} is the number of elements in the vector and the + field {\tt bitvec} contains the actual BDDs in the vector. + The C++ version of {\tt bvec} is documented at the beginning of + this document *} +*/ +typedef struct s_bvec +{ + int bitnum; + BDD *bitvec; +} BVEC; + +#ifndef CPLUSPLUS +typedef BVEC bvec; +#endif + + +#ifdef CPLUSPLUS +extern "C" { +#endif + + /* Prototypes for bvec.c */ +extern BVEC bvec_copy(BVEC v); +extern BVEC bvec_true(int bitnum); +extern BVEC bvec_false(int bitnum); +extern BVEC bvec_con(int bitnum, int val); +extern BVEC bvec_var(int bitnum, int offset, int step); +extern BVEC bvec_varfdd(int var); +extern BVEC bvec_varvec(int bitnum, int *var); +extern BVEC bvec_coerce(int bitnum, BVEC v); +extern int bvec_isconst(BVEC e); +extern int bvec_val(BVEC e); +extern void bvec_free(BVEC v); +extern BVEC bvec_addref(BVEC v); +extern BVEC bvec_delref(BVEC v); +extern BVEC bvec_map1(BVEC a, BDD (*fun)(BDD)); +extern BVEC bvec_map2(BVEC a, BVEC b, BDD (*fun)(BDD,BDD)); +extern BVEC bvec_map3(BVEC a, BVEC b, BVEC c, BDD (*fun)(BDD,BDD,BDD)); +extern BVEC bvec_add(BVEC left, BVEC right); +extern BVEC bvec_sub(BVEC left, BVEC right); +extern BVEC bvec_mulfixed(BVEC e, int c); +extern BVEC bvec_mul(BVEC left, BVEC right); +extern int bvec_divfixed(BVEC e, int c, BVEC *res, BVEC *rem); +extern int bvec_div(BVEC left, BVEC right, BVEC *res, BVEC *rem); +extern BVEC bvec_ite(BDD a, BVEC b, BVEC c); +extern BVEC bvec_shlfixed(BVEC e, int pos, BDD c); +extern BVEC bvec_shl(BVEC l, BVEC r, BDD c); +extern BVEC bvec_shrfixed(BVEC e, int pos, BDD c); +extern BVEC bvec_shr(BVEC l, BVEC r, BDD c); +extern BDD bvec_lth(BVEC left, BVEC right); +extern BDD bvec_lte(BVEC left, BVEC right); +extern BDD bvec_gth(BVEC left, BVEC right); +extern BDD bvec_gte(BVEC left, BVEC right); +extern BDD bvec_equ(BVEC left, BVEC right); +extern BDD bvec_neq(BVEC left, BVEC right); + +#ifdef CPLUSPLUS +} +#endif + + +/************************************************************************* + If this file is included from a C++ compiler then the following + classes, wrappers and hacks are supplied. +*************************************************************************/ +#ifdef CPLUSPLUS + +/*=== User BVEC class ==================================================*/ + +class bvec +{ + public: + + bvec(void) { roots.bitvec=NULL; roots.bitnum=0; } + bvec(int bitnum) { roots=bvec_false(bitnum); } + bvec(int bitnum, int val) { roots=bvec_con(bitnum,val); } + bvec(const bvec &v) { roots=bvec_copy(v.roots); } + ~bvec(void) { bvec_free(roots); } + + void set(int i, const bdd &b); + bdd operator[](int i) const { return roots.bitvec[i]; } + int bitnum(void) const { return roots.bitnum; } + int empty(void) const { return roots.bitnum==0; } + bvec operator=(const bvec &src); + +private: + BVEC roots; + + bvec(const BVEC &v) { roots=v; } /* NOTE: Must be a shallow copy! */ + + friend bvec bvec_truepp(int bitnum); + friend bvec bvec_falsepp(int bitnum); + friend bvec bvec_conpp(int bitnum, int val); + friend bvec bvec_varpp(int bitnum, int offset, int step); + friend bvec bvec_varfddpp(int var); + friend bvec bvec_varvecpp(int bitnum, int *var); + friend bvec bvec_coerce(int bitnum, const bvec &v); + friend int bvec_isconst(const bvec &e); + friend int bvec_val(const bvec &e); + friend bvec bvec_copy(const bvec &v); + friend bvec bvec_map1(const bvec &a, + bdd (*fun)(const bdd &)); + friend bvec bvec_map2(const bvec &a, const bvec &b, + bdd (*fun)(const bdd &, const bdd &)); + friend bvec bvec_map3(const bvec &a, const bvec &b, const bvec &c, + bdd (*fun)(const bdd &, const bdd &, const bdd &)); + friend bvec bvec_add(const bvec &left, const bvec &right); + friend bvec bvec_sub(const bvec &left, const bvec &right); + friend bvec bvec_mulfixed(const bvec &e, int c); + friend bvec bvec_mul(const bvec &left, const bvec &right); + friend int bvec_divfixed(const bvec &e, int c, bvec &res, bvec &rem); + friend int bvec_div(const bvec &l, const bvec &r, bvec &res, bvec &rem); + friend bvec bvec_ite(const bdd& a, const bvec& b, const bvec& c); + friend bvec bvec_shlfixed(const bvec &e, int pos, const bdd &c); + friend bvec bvec_shl(const bvec &left, const bvec &right, const bdd &c); + friend bvec bvec_shrfixed(const bvec &e, int pos, const bdd &c); + friend bvec bvec_shr(const bvec &left, const bvec &right, const bdd &c); + friend bdd bvec_lth(const bvec &left, const bvec &right); + friend bdd bvec_lte(const bvec &left, const bvec &right); + friend bdd bvec_gth(const bvec &left, const bvec &right); + friend bdd bvec_gte(const bvec &left, const bvec &right); + friend bdd bvec_equ(const bvec &left, const bvec &right); + friend bdd bvec_neq(const bvec &left, const bvec &right); + +public: + bvec operator&(const bvec &a) const { return bvec_map2(*this, a, bdd_and); } + bvec operator^(const bvec &a) const { return bvec_map2(*this, a, bdd_xor); } + bvec operator|(const bvec &a) const { return bvec_map2(*this, a, bdd_or); } + bvec operator!(void) const { return bvec_map1(*this, bdd_not); } + bvec operator<<(int a) const { return bvec_shlfixed(*this,a,bddfalse); } + bvec operator<<(const bvec &a) const { return bvec_shl(*this,a,bddfalse); } + bvec operator>>(int a) const { return bvec_shrfixed(*this,a,bddfalse); } + bvec operator>>(const bvec &a) const { return bvec_shr(*this,a,bddfalse); } + bvec operator+(const bvec &a) const { return bvec_add(*this, a); } + bvec operator-(const bvec &a) const { return bvec_sub(*this, a); } + bvec operator*(int a) const { return bvec_mulfixed(*this, a); } + bvec operator*(const bvec a) const { return bvec_mul(*this, a); } + bdd operator<(const bvec &a) const { return bvec_lth(*this, a); } + bdd operator<=(const bvec &a) const { return bvec_lte(*this, a); } + bdd operator>(const bvec &a) const { return bvec_gth(*this, a); } + bdd operator>=(const bvec &a) const { return bvec_gte(*this, a); } + bdd operator==(const bvec &a) const { return bvec_equ(*this, a); } + bdd operator!=(const bvec &a) const { return bvec_neq(*this, a); } +}; + +std::ostream &operator<<(std::ostream &, const bvec &); + +inline bvec bvec_truepp(int bitnum) +{ return bvec_true(bitnum); } + +inline bvec bvec_falsepp(int bitnum) +{ return bvec_false(bitnum); } + +inline bvec bvec_conpp(int bitnum, int val) +{ return bvec_con(bitnum, val); } + +inline bvec bvec_varpp(int bitnum, int offset, int step) +{ return bvec_var(bitnum, offset, step); } + +inline bvec bvec_varfddpp(int var) +{ return bvec_varfdd(var); } + +inline bvec bvec_varvecpp(int bitnum, int *var) +{ return bvec_varvec(bitnum, var); } + +inline bvec bvec_coerce(int bitnum, const bvec &v) +{ return bvec_coerce(bitnum, v.roots); } + +inline int bvec_isconst(const bvec &e) +{ return bvec_isconst(e.roots); } + +inline int bvec_val(const bvec &e) +{ return bvec_val(e.roots); } + +inline bvec bvec_copy(const bvec &v) +{ return bvec_copy(v.roots); } + +inline bvec bvec_add(const bvec &left, const bvec &right) +{ return bvec_add(left.roots, right.roots); } + +inline bvec bvec_sub(const bvec &left, const bvec &right) +{ return bvec_sub(left.roots, right.roots); } + +inline bvec bvec_mulfixed(const bvec &e, int c) +{ return bvec_mulfixed(e.roots, c); } + +inline bvec bvec_mul(const bvec &left, const bvec &right) +{ return bvec_mul(left.roots, right.roots); } + +inline int bvec_divfixed(const bvec &e, int c, bvec &res, bvec &rem) +{ return bvec_divfixed(e.roots, c, &res.roots, &rem.roots); } + +inline int bvec_div(const bvec &l, const bvec &r, bvec &res, bvec &rem) +{ return bvec_div(l.roots, r.roots, &res.roots, &rem.roots); } + +inline bvec bvec_ite(const bdd& a, const bvec& b, const bvec& c) +{ return bvec_ite(a.root, b.roots, c.roots); } + +inline bvec bvec_shlfixed(const bvec &e, int pos, const bdd &c) +{ return bvec_shlfixed(e.roots, pos, c.root); } + +inline bvec bvec_shl(const bvec &left, const bvec &right, const bdd &c) +{ return bvec_shl(left.roots, right.roots, c.root); } + +inline bvec bvec_shrfixed(const bvec &e, int pos, const bdd &c) +{ return bvec_shrfixed(e.roots, pos, c.root); } + +inline bvec bvec_shr(const bvec &left, const bvec &right, const bdd &c) +{ return bvec_shr(left.roots, right.roots, c.root); } + +inline bdd bvec_lth(const bvec &left, const bvec &right) +{ return bvec_lth(left.roots, right.roots); } + +inline bdd bvec_lte(const bvec &left, const bvec &right) +{ return bvec_lte(left.roots, right.roots); } + +inline bdd bvec_gth(const bvec &left, const bvec &right) +{ return bvec_gth(left.roots, right.roots); } + +inline bdd bvec_gte(const bvec &left, const bvec &right) +{ return bvec_gte(left.roots, right.roots); } + +inline bdd bvec_equ(const bvec &left, const bvec &right) +{ return bvec_equ(left.roots, right.roots); } + +inline bdd bvec_neq(const bvec &left, const bvec &right) +{ return bvec_neq(left.roots, right.roots); } + + + /* Hack to allow for overloading */ +#define bvec_var(a,b,c) bvec_varpp(a,b,c) +#define bvec_varfdd(a) bvec_varfddpp(a) +#define bvec_varvec(a,b) bvec_varvecpp(a,b) +#define bvec_true(a) bvec_truepp(a) +#define bvec_false(a) bvec_falsepp(a) +#define bvec_con(a,b) bvec_conpp((a),(b)) + + +#endif /* CPLUSPLUS */ + +#endif /* _BVEC_H */ + +/* EOF */ diff --git a/sdk/buddy-2.4/include/fdd.h b/sdk/buddy-2.4/include/fdd.h new file mode 100644 index 0000000..754ef92 --- /dev/null +++ b/sdk/buddy-2.4/include/fdd.h @@ -0,0 +1,174 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/fdd.h,v 1.1.1.1 2004/06/25 13:22:40 haimcohen Exp $ + FILE: fdd.h + DESCR: Finite domain data with BDDs + AUTH: Jorn Lind + DATE: (C) february 1999 +*************************************************************************/ + +#ifndef _FDD_H +#define _FDD_H + +#include "bdd.h" + + +#ifdef CPLUSPLUS +extern "C" { +#endif + +/* In file fdd.c */ + +extern int fdd_extdomain(int*, int); +extern int fdd_overlapdomain(int, int); +extern int fdd_overlapdomains(int*, int); +extern void fdd_clearall(void); +extern int fdd_domainnum(void); +extern int fdd_domainsize(int); +extern int fdd_varnum(int); +extern int* fdd_vars(int); +extern BDD fdd_ithvar(int, int); +extern int fdd_scanvar(BDD, int); +extern int* fdd_scanallvar(BDD); +extern BDD fdd_ithset(int); +extern BDD fdd_domain(int); +extern BDD fdd_equals(int, int); +extern bddfilehandler fdd_file_hook(bddfilehandler); +#ifdef CPLUSPLUS +extern bddstrmhandler fdd_strm_hook(bddstrmhandler); +#endif +extern void fdd_printset(BDD); +extern void fdd_fprintset(FILE*, BDD); +extern int fdd_scanset(BDD, int**, int*); +extern BDD fdd_makeset(int*, int); +extern int fdd_intaddvarblock(int, int, int); +extern int fdd_setpair(bddPair*, int, int); +extern int fdd_setpairs(bddPair*, int*, int*, int); + +#ifdef CPLUSPLUS +} +#endif + +/************************************************************************* + If this file is included from a C++ compiler then the following + classes, wrappers and hacks are supplied. +*************************************************************************/ +#ifdef CPLUSPLUS + + /* FDD extensions */ + +inline bdd fdd_ithvarpp(int var, int val) +{ return fdd_ithvar(var, val); } + +inline bdd fdd_ithsetpp(int var) +{ return fdd_ithset(var); } + +inline bdd fdd_domainpp(int var) +{ return fdd_domain(var); } + +inline int fdd_scanvar(const bdd &r, int var) +{ return fdd_scanvar(r.root, var); } + +inline int* fdd_scanallvar(const bdd &r) +{ return fdd_scanallvar(r.root); } + +inline bdd fdd_equalspp(int left, int right) +{ return fdd_equals(left, right); } + +inline void fdd_printset(const bdd &r) +{ fdd_printset(r.root); } + +inline void fdd_fprintset(FILE* ofile, const bdd &r) +{ fdd_fprintset(ofile, r.root); } + +inline int fdd_scanset(const bdd &r, int *&v, int &n) +{ return fdd_scanset(r.root, &v, &n); } + +inline bdd fdd_makesetpp(int *v, int n) +{ return fdd_makeset(v,n); } + +#if 0 +inline bdd* fdd_conpp(int bitnum, int var) +{ return fdd_transfer( bitnum, fdd_con(bitnum, var) ); } + +inline bdd* fdd_varpp(int bitnum, int var) +{ return fdd_transfer( bitnum, fdd_var(bitnum, var) ); } + +extern int fdd_isconst(int bitnum, bdd *e); +extern int fdd_val(int bitnum, bdd *e); + +inline bdd* fdd_add(int bitnum, bdd *left, bdd *right) +{ return fdd_termopr(bitnum, left, right,bdd::fddAdd); } + +inline bdd* fdd_sub(int bitnum, bdd *left, bdd *right) +{ return fdd_termopr(bitnum, left, right,bdd::fddSub); } + +inline bdd* fdd_shl(int bitnum, bdd *expr, bdd c) +{ return fdd_shift(bitnum, expr, c, bdd::fddShl); } + +inline bdd* fdd_shr(int bitnum, bdd *expr, bdd c) +{ return fdd_shift(bitnum, expr, c, bdd::fddShr); } + +inline bdd fdd_lth(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddLth); } + +inline bdd fdd_lte(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddLte); } + +inline bdd fdd_gth(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddGth); } + +inline bdd fdd_gte(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddGte); } + +inline bdd fdd_equ(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddEqu); } + +inline bdd fdd_neq(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddNeq); } +#endif + + /* Hacks to allow for overloading of return-types only */ +#define fdd_ithvar fdd_ithvarpp +#define fdd_ithset fdd_ithsetpp +#define fdd_domain fdd_domainpp +#define fdd_equals fdd_equalspp +#define fdd_makeset fdd_makesetpp +#define fdd_con fdd_conpp +#define fdd_var fdd_varpp + + +#endif /* CPLUSPLUS */ + +#endif /* _FDD_H */ + + +/* EOF */ diff --git a/sdk/buddy-2.4/libtool b/sdk/buddy-2.4/libtool new file mode 100644 index 0000000..7faae93 --- /dev/null +++ b/sdk/buddy-2.4/libtool @@ -0,0 +1,7381 @@ +#! /bin/bash + +# libtoolT - Provide generalized library-building support services. +# Generated automatically by (GNU buddy 2.4) +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 +# Free Software Foundation, Inc. +# +# This file is part of GNU Libtool: +# Originally by Gordon Matzigkeit , 1996 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# A sed program that does not truncate output. +SED="/bin/sed" + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="/bin/sed -e s/^X//" + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi + +# The names of the tagged configurations supported by this script. +available_tags=" CXX F77" + +# ### BEGIN LIBTOOL CONFIG + +# Libtool was configured on host ipf0v3330.pf.irt-aese.local: + +# Shell to use when invoking shell scripts. +SHELL="/bin/bash" + +# Whether or not to build shared libraries. +build_libtool_libs=yes + +# Whether or not to build static libraries. +build_old_libs=yes + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=no + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=no + +# Whether or not to optimize for fast installation. +fast_install=yes + +# The host system. +host_alias= +host=x86_64-unknown-linux-gnu + +# An echo program that does not interpret backslashes. +echo="echo" + +# The archiver. +AR="ar" +AR_FLAGS="cru" + +# A C compiler. +LTCC="gcc" + +# A language-specific compiler. +CC="gcc" + +# Is the compiler the GNU C compiler? +with_gcc=yes + +# An ERE matcher. +EGREP="/bin/grep -E" + +# The linker used to build libraries. +LD="/usr/bin/ld -m elf_x86_64" + +# Whether we need hard or soft links. +LN_S="ln -s" + +# A BSD-compatible nm program. +NM="/usr/bin/nm -B" + +# A symbol stripping program +STRIP="strip" + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=file + +# Used on cygwin: DLL creation program. +DLLTOOL="dlltool" + +# Used on cygwin: object dumper. +OBJDUMP="objdump" + +# Used on cygwin: assembler. +AS="as" + +# The name of the directory that contains temporary libtool files. +objdir=.libs + +# How to create reloadable object files. +reload_flag=" -r" +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs" + +# How to pass a linker flag through the compiler. +wl="-Wl," + +# Object file suffix (normally "o"). +objext="o" + +# Old archive suffix (normally "a"). +libext="a" + +# Shared library suffix (normally ".so"). +shrext_cmds='.so' + +# Executable file suffix (normally ""). +exeext="" + +# Additional compiler flags for building library objects. +pic_flag=" -fPIC -DPIC" +pic_mode=default + +# What is the maximum length of a command? +max_cmd_len=32768 + +# Does compiler simultaneously support -c and -o options? +compiler_c_o="yes" + +# Must we lock files when doing compilation ? +need_locks="no" + +# Do we need the lib prefix for modules? +need_lib_prefix=no + +# Do we need a version for libraries? +need_version=no + +# Whether dlopen is supported. +dlopen_support=unknown + +# Whether dlopen of programs is supported. +dlopen_self=unknown + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=unknown + +# Compiler flag to prevent dynamic linking. +link_static_flag="-static" + +# Compiler flag to turn off builtin functions. +no_builtin_flag=" -fno-builtin" + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec="\${wl}--export-dynamic" + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive" + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec="" + +# Library versioning type. +version_type=linux + +# Format of library name prefix. +libname_spec="lib\$name" + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}" + +# The coded name of the library, if different from the real name. +soname_spec="\${libname}\${release}\${shared_ext}\$major" + +# Commands used to build and install an old-style archive. +RANLIB="ranlib" +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs\$old_deplibs~\$RANLIB \$oldlib" +old_postinstall_cmds="\$RANLIB \$oldlib~chmod 644 \$oldlib" +old_postuninstall_cmds="" + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds="" + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds="" + +# Commands used to build and install a shared archive. +archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib" +archive_expsym_cmds="\$echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~ +cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~ +\$echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~ + \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib" +postinstall_cmds="" +postuninstall_cmds="" + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds="" +module_expsym_cmds="" + +# Commands to strip libraries. +old_striplib="strip --strip-debug" +striplib="strip --strip-unneeded" + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects="" + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects="" + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps="" + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps="" + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path="" + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method="pass_all" + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd="\$MAGIC_CMD" + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag="" + +# Flag that forces no undefined symbols. +no_undefined_flag="" + +# Commands used to finish a libtool library installation in a directory. +finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir" + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval="" + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\(\\)\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2\\3 \\3/p'" + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl="sed -n -e 's/^. .* \\(.*\\)\$/extern int \\1;/p'" + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/ {\\\"\\1\\\", (lt_ptr) 0},/p' -e 's/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/ {\"\\2\", (lt_ptr) \\&\\2},/p'" + +# This is the shared library runtime path variable. +runpath_var=LD_RUN_PATH + +# This is the shared library path variable. +shlibpath_var=LD_LIBRARY_PATH + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=no + +# How to hardcode a shared library path into an executable. +hardcode_action=immediate + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=yes + +# Flag to hardcode $libdir into a binary during linking. +# This must work even if $libdir does not exist. +hardcode_libdir_flag_spec="\${wl}--rpath \${wl}\$libdir" + +# If ld is used when linking, flag to hardcode $libdir into +# a binary during linking. This must work even if $libdir does +# not exist. +hardcode_libdir_flag_spec_ld="" + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator="" + +# Set to yes if using DIR/libNAME during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=no + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=no + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=unsupported + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=no + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=unknown + +# Compile-time system search path for libraries +sys_lib_search_path_spec="/lib64 /usr/lib64 /usr/X11R6/lib64 /usr/local/lib64 include /etc/ld.so.conf.d/*.conf " + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /usr/X11R6/lib64 include /etc/ld.so.conf.d/*.conf " + +# Fix the shell variable $srcfile for the compiler. +fix_srcfile_path="" + +# Set to yes if exported symbols are required. +always_export_symbols=no + +# The commands to list exported symbols. +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols" + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds="" + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms="_GLOBAL_OFFSET_TABLE_" + +# Symbols that must always be exported. +include_expsyms="" + +# ### END LIBTOOL CONFIG + +# ltmain.sh - Provide generalized library-building support services. +# NOTE: Changing this file will not affect anything until you rerun configure. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 +# Free Software Foundation, Inc. +# Originally by Gordon Matzigkeit , 1996 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +basename="s,^.*/,,g" + +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh +# is ksh but when the shell is invoked as "sh" and the current value of +# the _XPG environment variable is not equal to 1 (one), the special +# positional parameter $0, within a function call, is the name of the +# function. +progpath="$0" + +# define SED for historic ltconfig's generated by Libtool 1.3 +test -z "$SED" && SED=sed + +# The name of this program: +progname=`echo "$progpath" | $SED $basename` +modename="$progname" + +# Global variables: +EXIT_SUCCESS=0 +EXIT_FAILURE=1 + +PROGRAM=ltmain.sh +PACKAGE=libtool +VERSION=1.5.6 +TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42)" + + +# Check that we have a working $echo. +if test "X$1" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift +elif test "X$1" = X--fallback-echo; then + # Avoid inline document here, it may be left over + : +elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then + # Yippee, $echo works! + : +else + # Restart under the correct shell, and then maybe $echo will work. + exec $SHELL "$progpath" --no-reexec ${1+"$@"} +fi + +if test "X$1" = X--fallback-echo; then + # used as fallback echo + shift + cat <&2 + $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 + exit $EXIT_FAILURE +fi + +# Global variables. +mode=$default_mode +nonopt= +prev= +prevopt= +run= +show="$echo" +show_help= +execute_dlfiles= +lo2o="s/\\.lo\$/.${objext}/" +o2lo="s/\\.${objext}\$/.lo/" + +##################################### +# Shell function definitions: +# This seems to be the best place for them + +# func_win32_libid arg +# return the library type of file 'arg' +# +# Need a lot of goo to handle *both* DLLs and import libs +# Has to be a shell function in order to 'eat' the argument +# that is supplied when $file_magic_command is called. +func_win32_libid () { + win32_libid_type="unknown" + win32_fileres=`file -L $1 2>/dev/null` + case $win32_fileres in + *ar\ archive\ import\ library*) # definitely import + win32_libid_type="x86 archive import" + ;; + *ar\ archive*) # could be an import, or static + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \ + $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then + win32_nmres=`eval $NM -f posix -A $1 | \ + sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'` + if test "X$win32_nmres" = "Ximport" ; then + win32_libid_type="x86 archive import" + else + win32_libid_type="x86 archive static" + fi + fi + ;; + *DLL*) + win32_libid_type="x86 DLL" + ;; + *executable*) # but shell scripts are "executable" too... + case $win32_fileres in + *MS\ Windows\ PE\ Intel*) + win32_libid_type="x86 DLL" + ;; + esac + ;; + esac + $echo $win32_libid_type +} + + +# func_infer_tag arg +# Infer tagged configuration to use if any are available and +# if one wasn't chosen via the "--tag" command line option. +# Only attempt this if the compiler in the base compile +# command doesn't match the default compiler. +# arg is usually of the form 'gcc ...' +func_infer_tag () { + if test -n "$available_tags" && test -z "$tagname"; then + CC_quoted= + for arg in $CC; do + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + CC_quoted="$CC_quoted $arg" + done + case $@ in + # Blanks in the command may have been stripped by the calling shell, + # but not from the CC environment variable when configure was run. + " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;; + # Blanks at the start of $base_compile will cause this to fail + # if we don't check for them as well. + *) + for z in $available_tags; do + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" + CC_quoted= + for arg in $CC; do + # Double-quote args containing other shell metacharacters. + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + CC_quoted="$CC_quoted $arg" + done + case "$@ " in + " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) + # The compiler in the base compile command matches + # the one in the tagged configuration. + # Assume this is the tagged configuration we want. + tagname=$z + break + ;; + esac + fi + done + # If $tagname still isn't set, then no tagged configuration + # was found and let the user know that the "--tag" command + # line option must be used. + if test -z "$tagname"; then + $echo "$modename: unable to infer tagged configuration" + $echo "$modename: specify a tag with \`--tag'" 1>&2 + exit $EXIT_FAILURE +# else +# $echo "$modename: using $tagname tagged configuration" + fi + ;; + esac + fi +} +# End of Shell function definitions +##################################### + +# Darwin sucks +#eval std_shrext=\"$shrext_cmds\" + +# And fixing for Darwin sucks for everybody else +if test -z "$shrext_cmds" && test -n "$shrext"; then + eval shrext_cmds=\"$shrext\" +fi +eval std_shrext=\"$shrext_cmds\" + +# This value is evaluated to 32768, so place it here as a compatilibity hack +# because older libtool.m4 didn't define this variable +test -z "$max_cmd_len" && max_cmd_len=32768 + +# Parse our command line options once, thoroughly. +while test "$#" -gt 0 +do + arg="$1" + shift + + case $arg in + -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + execute_dlfiles) + execute_dlfiles="$execute_dlfiles $arg" + ;; + tag) + tagname="$arg" + preserve_args="${preserve_args}=$arg" + + # Check whether tagname contains only valid characters + case $tagname in + *[!-_A-Za-z0-9,/]*) + $echo "$progname: invalid tag name: $tagname" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + case $tagname in + CC) + # Don't test for the "default" C tag, as we know, it's there, but + # not specially marked. + ;; + *) + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then + taglist="$taglist $tagname" + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`" + else + $echo "$progname: ignoring unknown tag $tagname" 1>&2 + fi + ;; + esac + ;; + *) + eval "$prev=\$arg" + ;; + esac + + prev= + prevopt= + continue + fi + + # Have we seen a non-optional argument yet? + case $arg in + --help) + show_help=yes + ;; + + --version) + $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP" + $echo + $echo "Copyright (C) 2003 Free Software Foundation, Inc." + $echo "This is free software; see the source for copying conditions. There is NO" + $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + exit $EXIT_SUCCESS + ;; + + --config) + ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath + # Now print the configurations for the tags. + for tagname in $taglist; do + ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath" + done + exit $EXIT_SUCCESS + ;; + + --debug) + $echo "$progname: enabling shell trace mode" + set -x + preserve_args="$preserve_args $arg" + ;; + + --dry-run | -n) + run=: + ;; + + --features) + $echo "host: $host" + if test "$build_libtool_libs" = yes; then + $echo "enable shared libraries" + else + $echo "disable shared libraries" + fi + if test "$build_old_libs" = yes; then + $echo "enable static libraries" + else + $echo "disable static libraries" + fi + exit $EXIT_SUCCESS + ;; + + --finish) mode="finish" ;; + + --mode) prevopt="--mode" prev=mode ;; + --mode=*) mode="$optarg" ;; + + --preserve-dup-deps) duplicate_deps="yes" ;; + + --quiet | --silent) + show=: + preserve_args="$preserve_args $arg" + ;; + + --tag) prevopt="--tag" prev=tag ;; + --tag=*) + set tag "$optarg" ${1+"$@"} + shift + prev=tag + preserve_args="$preserve_args --tag" + ;; + + -dlopen) + prevopt="-dlopen" + prev=execute_dlfiles + ;; + + -*) + $echo "$modename: unrecognized option \`$arg'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + + *) + nonopt="$arg" + break + ;; + esac +done + +if test -n "$prevopt"; then + $echo "$modename: option \`$prevopt' requires an argument" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE +fi + +# If this variable is set in any of the actions, the command in it +# will be execed at the end. This prevents here-documents from being +# left over by shells. +exec_cmd= + +if test -z "$show_help"; then + + # Infer the operation mode. + if test -z "$mode"; then + $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2 + $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2 + case $nonopt in + *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*) + mode=link + for arg + do + case $arg in + -c) + mode=compile + break + ;; + esac + done + ;; + *db | *dbx | *strace | *truss) + mode=execute + ;; + *install*|cp|mv) + mode=install + ;; + *rm) + mode=uninstall + ;; + *) + # If we have no mode, but dlfiles were specified, then do execute mode. + test -n "$execute_dlfiles" && mode=execute + + # Just use the default operation mode. + if test -z "$mode"; then + if test -n "$nonopt"; then + $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2 + else + $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2 + fi + fi + ;; + esac + fi + + # Only execute mode is allowed to have -dlopen flags. + if test -n "$execute_dlfiles" && test "$mode" != execute; then + $echo "$modename: unrecognized option \`-dlopen'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Change the help message to a mode-specific one. + generic_help="$help" + help="Try \`$modename --help --mode=$mode' for more information." + + # These modes are in order of execution frequency so that they run quickly. + case $mode in + # libtool compile mode + compile) + modename="$modename: compile" + # Get the compilation command and the source file. + base_compile= + srcfile="$nonopt" # always keep a non-empty value in "srcfile" + suppress_opt=yes + suppress_output= + arg_mode=normal + libobj= + later= + + for arg + do + case "$arg_mode" in + arg ) + # do not "continue". Instead, add this to base_compile + lastarg="$arg" + arg_mode=normal + ;; + + target ) + libobj="$arg" + arg_mode=normal + continue + ;; + + normal ) + # Accept any command-line options. + case $arg in + -o) + if test -n "$libobj" ; then + $echo "$modename: you cannot specify \`-o' more than once" 1>&2 + exit $EXIT_FAILURE + fi + arg_mode=target + continue + ;; + + -static | -prefer-pic | -prefer-non-pic) + later="$later $arg" + continue + ;; + + -no-suppress) + suppress_opt=no + continue + ;; + + -Xcompiler) + arg_mode=arg # the next one goes into the "base_compile" arg list + continue # The current "srcfile" will either be retained or + ;; # replaced later. I would guess that would be a bug. + + -Wc,*) + args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"` + lastarg= + save_ifs="$IFS"; IFS=',' + for arg in $args; do + IFS="$save_ifs" + + # Double-quote args containing other shell metacharacters. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + lastarg="$lastarg $arg" + done + IFS="$save_ifs" + lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"` + + # Add the arguments to base_compile. + base_compile="$base_compile $lastarg" + continue + ;; + + * ) + # Accept the current argument as the source file. + # The previous "srcfile" becomes the current argument. + # + lastarg="$srcfile" + srcfile="$arg" + ;; + esac # case $arg + ;; + esac # case $arg_mode + + # Aesthetically quote the previous argument. + lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"` + + case $lastarg in + # Double-quote args containing other shell metacharacters. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + lastarg="\"$lastarg\"" + ;; + esac + + base_compile="$base_compile $lastarg" + done # for arg + + case $arg_mode in + arg) + $echo "$modename: you must specify an argument for -Xcompile" + exit $EXIT_FAILURE + ;; + target) + $echo "$modename: you must specify a target with \`-o'" 1>&2 + exit $EXIT_FAILURE + ;; + *) + # Get the name of the library object. + [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'` + ;; + esac + + # Recognize several different file suffixes. + # If the user specifies -o file.o, it is replaced with file.lo + xform='[cCFSifmso]' + case $libobj in + *.ada) xform=ada ;; + *.adb) xform=adb ;; + *.ads) xform=ads ;; + *.asm) xform=asm ;; + *.c++) xform=c++ ;; + *.cc) xform=cc ;; + *.ii) xform=ii ;; + *.class) xform=class ;; + *.cpp) xform=cpp ;; + *.cxx) xform=cxx ;; + *.f90) xform=f90 ;; + *.for) xform=for ;; + *.java) xform=java ;; + esac + + libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"` + + case $libobj in + *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;; + *) + $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + func_infer_tag $base_compile + + for arg in $later; do + case $arg in + -static) + build_old_libs=yes + continue + ;; + + -prefer-pic) + pic_mode=yes + continue + ;; + + -prefer-non-pic) + pic_mode=no + continue + ;; + esac + done + + objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'` + xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$obj"; then + xdir= + else + xdir=$xdir/ + fi + lobj=${xdir}$objdir/$objname + + if test -z "$base_compile"; then + $echo "$modename: you must specify a compilation command" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Delete any leftover library objects. + if test "$build_old_libs" = yes; then + removelist="$obj $lobj $libobj ${libobj}T" + else + removelist="$lobj $libobj ${libobj}T" + fi + + $run $rm $removelist + trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15 + + # On Cygwin there's no "real" PIC flag so we must build both object types + case $host_os in + cygwin* | mingw* | pw32* | os2*) + pic_mode=default + ;; + esac + if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then + # non-PIC code in shared libraries is not supported + pic_mode=default + fi + + # Calculate the filename of the output object if compiler does + # not support -o with -c + if test "$compiler_c_o" = no; then + output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext} + lockfile="$output_obj.lock" + removelist="$removelist $output_obj $lockfile" + trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15 + else + output_obj= + need_locks=no + lockfile= + fi + + # Lock this critical section if it is needed + # We use this script file to make the link, it avoids creating a new file + if test "$need_locks" = yes; then + until $run ln "$progpath" "$lockfile" 2>/dev/null; do + $show "Waiting for $lockfile to be removed" + sleep 2 + done + elif test "$need_locks" = warn; then + if test -f "$lockfile"; then + $echo "\ +*** ERROR, $lockfile exists and contains: +`cat $lockfile 2>/dev/null` + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $run $rm $removelist + exit $EXIT_FAILURE + fi + $echo $srcfile > "$lockfile" + fi + + if test -n "$fix_srcfile_path"; then + eval srcfile=\"$fix_srcfile_path\" + fi + + $run $rm "$libobj" "${libobj}T" + + # Create a libtool object file (analogous to a ".la" file), + # but don't create it if we're doing a dry run. + test -z "$run" && cat > ${libobj}T </dev/null`" != "X$srcfile"; then + $echo "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $run $rm $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed, then go on to compile the next one + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then + $show "$mv $output_obj $lobj" + if $run $mv $output_obj $lobj; then : + else + error=$? + $run $rm $removelist + exit $error + fi + fi + + # Append the name of the PIC object to the libtool object file. + test -z "$run" && cat >> ${libobj}T <> ${libobj}T </dev/null`" != "X$srcfile"; then + $echo "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $run $rm $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then + $show "$mv $output_obj $obj" + if $run $mv $output_obj $obj; then : + else + error=$? + $run $rm $removelist + exit $error + fi + fi + + # Append the name of the non-PIC object the libtool object file. + # Only append if the libtool object file exists. + test -z "$run" && cat >> ${libobj}T <> ${libobj}T <&2 + fi + if test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + else + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + fi + build_libtool_libs=no + build_old_libs=yes + prefer_static_libs=yes + break + ;; + esac + done + + # See if our shared archives depend on static archives. + test -n "$old_archive_from_new_cmds" && build_old_libs=yes + + # Go through the arguments, transforming them on the way. + while test "$#" -gt 0; do + arg="$1" + shift + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test + ;; + *) qarg=$arg ;; + esac + libtool_args="$libtool_args $qarg" + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + output) + compile_command="$compile_command @OUTPUT@" + finalize_command="$finalize_command @OUTPUT@" + ;; + esac + + case $prev in + dlfiles|dlprefiles) + if test "$preload" = no; then + # Add the symbol object into the linking commands. + compile_command="$compile_command @SYMFILE@" + finalize_command="$finalize_command @SYMFILE@" + preload=yes + fi + case $arg in + *.la | *.lo) ;; # We handle these cases below. + force) + if test "$dlself" = no; then + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + self) + if test "$prev" = dlprefiles; then + dlself=yes + elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then + dlself=yes + else + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + *) + if test "$prev" = dlfiles; then + dlfiles="$dlfiles $arg" + else + dlprefiles="$dlprefiles $arg" + fi + prev= + continue + ;; + esac + ;; + expsyms) + export_symbols="$arg" + if test ! -f "$arg"; then + $echo "$modename: symbol file \`$arg' does not exist" + exit $EXIT_FAILURE + fi + prev= + continue + ;; + expsyms_regex) + export_symbols_regex="$arg" + prev= + continue + ;; + inst_prefix) + inst_prefix_dir="$arg" + prev= + continue + ;; + precious_regex) + precious_files_regex="$arg" + prev= + continue + ;; + release) + release="-$arg" + prev= + continue + ;; + objectlist) + if test -f "$arg"; then + save_arg=$arg + moreargs= + for fil in `cat $save_arg` + do +# moreargs="$moreargs $fil" + arg=$fil + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + pic_object= + non_pic_object= + + # Read the .lo file + # If there is no directory component, then add one. + case $arg in + */* | *\\*) . $arg ;; + *) . ./$arg ;; + esac + + if test -z "$pic_object" || \ + test -z "$non_pic_object" || + test "$pic_object" = none && \ + test "$non_pic_object" = none; then + $echo "$modename: cannot find name of object for \`$arg'" 1>&2 + exit $EXIT_FAILURE + fi + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + dlfiles="$dlfiles $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + dlprefiles="$dlprefiles $pic_object" + prev= + fi + + # A PIC object. + libobjs="$libobjs $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + non_pic_objects="$non_pic_objects $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + fi + else + # Only an error if not doing a dry-run. + if test -z "$run"; then + $echo "$modename: \`$arg' is not a valid libtool object" 1>&2 + exit $EXIT_FAILURE + else + # Dry-run case. + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"` + non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"` + libobjs="$libobjs $pic_object" + non_pic_objects="$non_pic_objects $non_pic_object" + fi + fi + done + else + $echo "$modename: link input file \`$save_arg' does not exist" + exit $EXIT_FAILURE + fi + arg=$save_arg + prev= + continue + ;; + rpath | xrpath) + # We need an absolute path. + case $arg in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + $echo "$modename: only absolute run-paths are allowed" 1>&2 + exit $EXIT_FAILURE + ;; + esac + if test "$prev" = rpath; then + case "$rpath " in + *" $arg "*) ;; + *) rpath="$rpath $arg" ;; + esac + else + case "$xrpath " in + *" $arg "*) ;; + *) xrpath="$xrpath $arg" ;; + esac + fi + prev= + continue + ;; + xcompiler) + compiler_flags="$compiler_flags $qarg" + prev= + compile_command="$compile_command $qarg" + finalize_command="$finalize_command $qarg" + continue + ;; + xlinker) + linker_flags="$linker_flags $qarg" + compiler_flags="$compiler_flags $wl$qarg" + prev= + compile_command="$compile_command $wl$qarg" + finalize_command="$finalize_command $wl$qarg" + continue + ;; + xcclinker) + linker_flags="$linker_flags $qarg" + compiler_flags="$compiler_flags $qarg" + prev= + compile_command="$compile_command $qarg" + finalize_command="$finalize_command $qarg" + continue + ;; + shrext) + shrext_cmds="$arg" + prev= + continue + ;; + *) + eval "$prev=\"\$arg\"" + prev= + continue + ;; + esac + fi # test -n "$prev" + + prevarg="$arg" + + case $arg in + -all-static) + if test -n "$link_static_flag"; then + compile_command="$compile_command $link_static_flag" + finalize_command="$finalize_command $link_static_flag" + fi + continue + ;; + + -allow-undefined) + # FIXME: remove this flag sometime in the future. + $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2 + continue + ;; + + -avoid-version) + avoid_version=yes + continue + ;; + + -dlopen) + prev=dlfiles + continue + ;; + + -dlpreopen) + prev=dlprefiles + continue + ;; + + -export-dynamic) + export_dynamic=yes + continue + ;; + + -export-symbols | -export-symbols-regex) + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + $echo "$modename: more than one -exported-symbols argument is not allowed" + exit $EXIT_FAILURE + fi + if test "X$arg" = "X-export-symbols"; then + prev=expsyms + else + prev=expsyms_regex + fi + continue + ;; + + -inst-prefix-dir) + prev=inst_prefix + continue + ;; + + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* + # so, if we see these flags be careful not to treat them like -L + -L[A-Z][A-Z]*:*) + case $with_gcc/$host in + no/*-*-irix* | /*-*-irix*) + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + ;; + esac + continue + ;; + + -L*) + dir=`$echo "X$arg" | $Xsed -e 's/^-L//'` + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2 + exit $EXIT_FAILURE + fi + dir="$absdir" + ;; + esac + case "$deplibs " in + *" -L$dir "*) ;; + *) + deplibs="$deplibs -L$dir" + lib_search_path="$lib_search_path $dir" + ;; + esac + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) + case :$dllsearchpath: in + *":$dir:"*) ;; + *) dllsearchpath="$dllsearchpath:$dir";; + esac + ;; + esac + continue + ;; + + -l*) + if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then + case $host in + *-*-cygwin* | *-*-pw32* | *-*-beos*) + # These systems don't actually have a C or math library (as such) + continue + ;; + *-*-mingw* | *-*-os2*) + # These systems don't actually have a C library (as such) + test "X$arg" = "X-lc" && continue + ;; + *-*-openbsd* | *-*-freebsd*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C and math libraries are in the System framework + deplibs="$deplibs -framework System" + continue + esac + elif test "X$arg" = "X-lc_r"; then + case $host in + *-*-openbsd* | *-*-freebsd*) + # Do not include libc_r directly, use -pthread flag. + continue + ;; + esac + fi + deplibs="$deplibs $arg" + continue + ;; + + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe) + deplibs="$deplibs $arg" + continue + ;; + + -module) + module=yes + continue + ;; + + # gcc -m* arguments should be passed to the linker via $compiler_flags + # in order to pass architecture information to the linker + # (e.g. 32 vs 64-bit). This may also be accomplished via -Wl,-mfoo + # but this is not reliable with gcc because gcc may use -mfoo to + # select a different linker, different libraries, etc, while + # -Wl,-mfoo simply passes -mfoo to the linker. + -m*) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + if test "$with_gcc" = "yes" ; then + compiler_flags="$compiler_flags $arg" + fi + continue + ;; + + -shrext) + prev=shrext + continue + ;; + + -no-fast-install) + fast_install=no + continue + ;; + + -no-install) + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) + # The PATH hackery in wrapper scripts is required on Windows + # in order for the loader to find any dlls it needs. + $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2 + $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2 + fast_install=no + ;; + *) no_install=yes ;; + esac + continue + ;; + + -no-undefined) + allow_undefined=no + continue + ;; + + -objectlist) + prev=objectlist + continue + ;; + + -o) prev=output ;; + + -precious-files-regex) + prev=precious_regex + continue + ;; + + -release) + prev=release + continue + ;; + + -rpath) + prev=rpath + continue + ;; + + -R) + prev=xrpath + continue + ;; + + -R*) + dir=`$echo "X$arg" | $Xsed -e 's/^-R//'` + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + $echo "$modename: only absolute run-paths are allowed" 1>&2 + exit $EXIT_FAILURE + ;; + esac + case "$xrpath " in + *" $dir "*) ;; + *) xrpath="$xrpath $dir" ;; + esac + continue + ;; + + -static) + # The effects of -static are defined in a previous loop. + # We used to do the same as -all-static on platforms that + # didn't have a PIC flag, but the assumption that the effects + # would be equivalent was wrong. It would break on at least + # Digital Unix and AIX. + continue + ;; + + -thread-safe) + thread_safe=yes + continue + ;; + + -version-info) + prev=vinfo + continue + ;; + -version-number) + prev=vinfo + vinfo_number=yes + continue + ;; + + -Wc,*) + args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'` + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + case $flag in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + flag="\"$flag\"" + ;; + esac + arg="$arg $wl$flag" + compiler_flags="$compiler_flags $flag" + done + IFS="$save_ifs" + arg=`$echo "X$arg" | $Xsed -e "s/^ //"` + ;; + + -Wl,*) + args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'` + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + case $flag in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + flag="\"$flag\"" + ;; + esac + arg="$arg $wl$flag" + compiler_flags="$compiler_flags $wl$flag" + linker_flags="$linker_flags $flag" + done + IFS="$save_ifs" + arg=`$echo "X$arg" | $Xsed -e "s/^ //"` + ;; + + -Xcompiler) + prev=xcompiler + continue + ;; + + -Xlinker) + prev=xlinker + continue + ;; + + -XCClinker) + prev=xcclinker + continue + ;; + + # Some other compiler flag. + -* | +*) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + ;; + + *.$objext) + # A standard object. + objs="$objs $arg" + ;; + + *.lo) + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + pic_object= + non_pic_object= + + # Read the .lo file + # If there is no directory component, then add one. + case $arg in + */* | *\\*) . $arg ;; + *) . ./$arg ;; + esac + + if test -z "$pic_object" || \ + test -z "$non_pic_object" || + test "$pic_object" = none && \ + test "$non_pic_object" = none; then + $echo "$modename: cannot find name of object for \`$arg'" 1>&2 + exit $EXIT_FAILURE + fi + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + dlfiles="$dlfiles $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + dlprefiles="$dlprefiles $pic_object" + prev= + fi + + # A PIC object. + libobjs="$libobjs $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + non_pic_objects="$non_pic_objects $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + fi + else + # Only an error if not doing a dry-run. + if test -z "$run"; then + $echo "$modename: \`$arg' is not a valid libtool object" 1>&2 + exit $EXIT_FAILURE + else + # Dry-run case. + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"` + non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"` + libobjs="$libobjs $pic_object" + non_pic_objects="$non_pic_objects $non_pic_object" + fi + fi + ;; + + *.$libext) + # An archive. + deplibs="$deplibs $arg" + old_deplibs="$old_deplibs $arg" + continue + ;; + + *.la) + # A libtool-controlled library. + + if test "$prev" = dlfiles; then + # This library was specified with -dlopen. + dlfiles="$dlfiles $arg" + prev= + elif test "$prev" = dlprefiles; then + # The library was specified with -dlpreopen. + dlprefiles="$dlprefiles $arg" + prev= + else + deplibs="$deplibs $arg" + fi + continue + ;; + + # Some other compiler argument. + *) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + ;; + esac # arg + + # Now actually substitute the argument into the commands. + if test -n "$arg"; then + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + fi + done # argument parsing loop + + if test -n "$prev"; then + $echo "$modename: the \`$prevarg' option requires an argument" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then + eval arg=\"$export_dynamic_flag_spec\" + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + fi + + oldlibs= + # calculate the name of the file, without its directory + outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'` + libobjs_save="$libobjs" + + if test -n "$shlibpath_var"; then + # get the directories listed in $shlibpath_var + eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\` + else + shlib_search_path= + fi + eval sys_lib_search_path=\"$sys_lib_search_path_spec\" + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" + + output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'` + if test "X$output_objdir" = "X$output"; then + output_objdir="$objdir" + else + output_objdir="$output_objdir/$objdir" + fi + # Create the object directory. + if test ! -d "$output_objdir"; then + $show "$mkdir $output_objdir" + $run $mkdir $output_objdir + status=$? + if test "$status" -ne 0 && test ! -d "$output_objdir"; then + exit $status + fi + fi + + # Determine the type of output + case $output in + "") + $echo "$modename: you must specify an output file" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + *.$libext) linkmode=oldlib ;; + *.lo | *.$objext) linkmode=obj ;; + *.la) linkmode=lib ;; + *) linkmode=prog ;; # Anything else should be a program. + esac + + case $host in + *cygwin* | *mingw* | *pw32*) + # don't eliminate duplications in $postdeps and $predeps + duplicate_compiler_generated_deps=yes + ;; + *) + duplicate_compiler_generated_deps=$duplicate_deps + ;; + esac + specialdeplibs= + + libs= + # Find all interdependent deplibs by searching for libraries + # that are linked more than once (e.g. -la -lb -la) + for deplib in $deplibs; do + if test "X$duplicate_deps" = "Xyes" ; then + case "$libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + libs="$libs $deplib" + done + + if test "$linkmode" = lib; then + libs="$predeps $libs $compiler_lib_search_path $postdeps" + + # Compute libraries that are listed more than once in $predeps + # $postdeps and mark them as special (i.e., whose duplicates are + # not to be eliminated). + pre_post_deps= + if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then + for pre_post_dep in $predeps $postdeps; do + case "$pre_post_deps " in + *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;; + esac + pre_post_deps="$pre_post_deps $pre_post_dep" + done + fi + pre_post_deps= + fi + + deplibs= + newdependency_libs= + newlib_search_path= + need_relink=no # whether we're linking any uninstalled libtool libraries + notinst_deplibs= # not-installed libtool libraries + notinst_path= # paths that contain not-installed libtool libraries + case $linkmode in + lib) + passes="conv link" + for file in $dlfiles $dlprefiles; do + case $file in + *.la) ;; + *) + $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2 + exit $EXIT_FAILURE + ;; + esac + done + ;; + prog) + compile_deplibs= + finalize_deplibs= + alldeplibs=no + newdlfiles= + newdlprefiles= + passes="conv scan dlopen dlpreopen link" + ;; + *) passes="conv" + ;; + esac + for pass in $passes; do + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan"; then + libs="$deplibs" + deplibs= + fi + if test "$linkmode" = prog; then + case $pass in + dlopen) libs="$dlfiles" ;; + dlpreopen) libs="$dlprefiles" ;; + link) libs="$deplibs %DEPLIBS% $dependency_libs" ;; + esac + fi + if test "$pass" = dlopen; then + # Collect dlpreopened libraries + save_deplibs="$deplibs" + deplibs= + fi + for deplib in $libs; do + lib= + found=no + case $deplib in + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + fi + continue + ;; + -l*) + if test "$linkmode" != lib && test "$linkmode" != prog; then + $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2 + continue + fi + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + name=`$echo "X$deplib" | $Xsed -e 's/^-l//'` + for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do + for search_ext in .la $std_shrext .so .a; do + # Search the libtool library + lib="$searchdir/lib${name}${search_ext}" + if test -f "$lib"; then + if test "$search_ext" = ".la"; then + found=yes + else + found=no + fi + break 2 + fi + done + done + if test "$found" != yes; then + # deplib doesn't seem to be a libtool library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + else # deplib is a libtool library + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, + # We need to do some special things here, and not later. + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $deplib "*) + if (${SED} -e '2q' $lib | + grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + library_names= + old_library= + case $lib in + */* | *\\*) . $lib ;; + *) . ./$lib ;; + esac + for l in $old_library $library_names; do + ll="$l" + done + if test "X$ll" = "X$old_library" ; then # only static version available + found=no + ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'` + test "X$ladir" = "X$lib" && ladir="." + lib=$ladir/$old_library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + fi + fi + ;; + *) ;; + esac + fi + fi + ;; # -l + -L*) + case $linkmode in + lib) + deplibs="$deplib $deplibs" + test "$pass" = conv && continue + newdependency_libs="$deplib $newdependency_libs" + newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'` + ;; + prog) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + if test "$pass" = scan; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'` + ;; + *) + $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2 + ;; + esac # linkmode + continue + ;; # -L + -R*) + if test "$pass" = link; then + dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'` + # Make sure the xrpath contains only unique directories. + case "$xrpath " in + *" $dir "*) ;; + *) xrpath="$xrpath $dir" ;; + esac + fi + deplibs="$deplib $deplibs" + continue + ;; + *.la) lib="$deplib" ;; + *.$libext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + case $linkmode in + lib) + if test "$deplibs_check_method" != pass_all; then + $echo + $echo "*** Warning: Trying to link with static lib archive $deplib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have" + $echo "*** because the file extensions .$libext of this argument makes me believe" + $echo "*** that it is just a static archive that I should not used here." + else + $echo + $echo "*** Warning: Linking the shared library $output against the" + $echo "*** static library $deplib is not portable!" + deplibs="$deplib $deplibs" + fi + continue + ;; + prog) + if test "$pass" != link; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + continue + ;; + esac # linkmode + ;; # *.$libext + *.lo | *.$objext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + elif test "$linkmode" = prog; then + if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then + # If there is no dlopen support or we're linking statically, + # we need to preload. + newdlprefiles="$newdlprefiles $deplib" + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + newdlfiles="$newdlfiles $deplib" + fi + fi + continue + ;; + %DEPLIBS%) + alldeplibs=yes + continue + ;; + esac # case $deplib + if test "$found" = yes || test -f "$lib"; then : + else + $echo "$modename: cannot find the library \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + + # Check to see that this really is a libtool archive. + if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then : + else + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + + ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'` + test "X$ladir" = "X$lib" && ladir="." + + dlname= + dlopen= + dlpreopen= + libdir= + library_names= + old_library= + # If the library was installed with an old release of libtool, + # it will not redefine variables installed, or shouldnotlink + installed=yes + shouldnotlink=no + + # Read the .la file + case $lib in + */* | *\\*) . $lib ;; + *) . ./$lib ;; + esac + + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan" || + { test "$linkmode" != prog && test "$linkmode" != lib; }; then + test -n "$dlopen" && dlfiles="$dlfiles $dlopen" + test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen" + fi + + if test "$pass" = conv; then + # Only check for convenience libraries + deplibs="$lib $deplibs" + if test -z "$libdir"; then + if test -z "$old_library"; then + $echo "$modename: cannot find name of link library for \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + # It is a libtool convenience library, so add in its objects. + convenience="$convenience $ladir/$objdir/$old_library" + old_convenience="$old_convenience $ladir/$objdir/$old_library" + tmp_libs= + for deplib in $dependency_libs; do + deplibs="$deplib $deplibs" + if test "X$duplicate_deps" = "Xyes" ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + tmp_libs="$tmp_libs $deplib" + done + elif test "$linkmode" != prog && test "$linkmode" != lib; then + $echo "$modename: \`$lib' is not a convenience library" 1>&2 + exit $EXIT_FAILURE + fi + continue + fi # $pass = conv + + + # Get the name of the library we link against. + linklib= + for l in $old_library $library_names; do + linklib="$l" + done + if test -z "$linklib"; then + $echo "$modename: cannot find name of link library for \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + + # This library was specified with -dlopen. + if test "$pass" = dlopen; then + if test -z "$libdir"; then + $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + if test -z "$dlname" || + test "$dlopen_support" != yes || + test "$build_libtool_libs" = no; then + # If there is no dlname, no dlopen support or we're linking + # statically, we need to preload. We also need to preload any + # dependent libraries so libltdl's deplib preloader doesn't + # bomb out in the load deplibs phase. + dlprefiles="$dlprefiles $lib $dependency_libs" + else + newdlfiles="$newdlfiles $lib" + fi + continue + fi # $pass = dlopen + + # We need an absolute path. + case $ladir in + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; + *) + abs_ladir=`cd "$ladir" && pwd` + if test -z "$abs_ladir"; then + $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2 + $echo "$modename: passing it literally to the linker, although it might fail" 1>&2 + abs_ladir="$ladir" + fi + ;; + esac + laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'` + + # Find the relevant object directory and library name. + if test "X$installed" = Xyes; then + if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then + $echo "$modename: warning: library \`$lib' was moved." 1>&2 + dir="$ladir" + absdir="$abs_ladir" + libdir="$abs_ladir" + else + dir="$libdir" + absdir="$libdir" + fi + else + dir="$ladir/$objdir" + absdir="$abs_ladir/$objdir" + # Remove this search path later + notinst_path="$notinst_path $abs_ladir" + fi # $installed = yes + name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'` + + # This library was specified with -dlpreopen. + if test "$pass" = dlpreopen; then + if test -z "$libdir"; then + $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + # Prefer using a static library (so that no silly _DYNAMIC symbols + # are required to link). + if test -n "$old_library"; then + newdlprefiles="$newdlprefiles $dir/$old_library" + # Otherwise, use the dlname, so that lt_dlopen finds it. + elif test -n "$dlname"; then + newdlprefiles="$newdlprefiles $dir/$dlname" + else + newdlprefiles="$newdlprefiles $dir/$linklib" + fi + fi # $pass = dlpreopen + + if test -z "$libdir"; then + # Link the convenience library + if test "$linkmode" = lib; then + deplibs="$dir/$old_library $deplibs" + elif test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$dir/$old_library $compile_deplibs" + finalize_deplibs="$dir/$old_library $finalize_deplibs" + else + deplibs="$lib $deplibs" # used for prog,scan pass + fi + continue + fi + + + if test "$linkmode" = prog && test "$pass" != link; then + newlib_search_path="$newlib_search_path $ladir" + deplibs="$lib $deplibs" + + linkalldeplibs=no + if test "$link_all_deplibs" != no || test -z "$library_names" || + test "$build_libtool_libs" = no; then + linkalldeplibs=yes + fi + + tmp_libs= + for deplib in $dependency_libs; do + case $deplib in + -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test + esac + # Need to link against all dependency_libs? + if test "$linkalldeplibs" = yes; then + deplibs="$deplib $deplibs" + else + # Need to hardcode shared library paths + # or/and link against static libraries + newdependency_libs="$deplib $newdependency_libs" + fi + if test "X$duplicate_deps" = "Xyes" ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + tmp_libs="$tmp_libs $deplib" + done # for deplib + continue + fi # $linkmode = prog... + + if test "$linkmode,$pass" = "prog,link"; then + if test -n "$library_names" && + { test "$prefer_static_libs" = no || test -z "$old_library"; }; then + # We need to hardcode the library path + if test -n "$shlibpath_var"; then + # Make sure the rpath contains only unique directories. + case "$temp_rpath " in + *" $dir "*) ;; + *" $absdir "*) ;; + *) temp_rpath="$temp_rpath $dir" ;; + esac + fi + + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) compile_rpath="$compile_rpath $absdir" + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" + esac + ;; + esac + fi # $linkmode,$pass = prog,link... + + if test "$alldeplibs" = yes && + { test "$deplibs_check_method" = pass_all || + { test "$build_libtool_libs" = yes && + test -n "$library_names"; }; }; then + # We only need to search for static libraries + continue + fi + fi + + link_static=no # Whether the deplib will be linked statically + if test -n "$library_names" && + { test "$prefer_static_libs" = no || test -z "$old_library"; }; then + if test "$installed" = no; then + notinst_deplibs="$notinst_deplibs $lib" + need_relink=yes + fi + # This is a shared library + + # Warn about portability, can't link against -module's on + # some systems (darwin) + if test "$shouldnotlink" = yes && test "$pass" = link ; then + $echo + if test "$linkmode" = prog; then + $echo "*** Warning: Linking the executable $output against the loadable module" + else + $echo "*** Warning: Linking the shared library $output against the loadable module" + fi + $echo "*** $linklib is not portable!" + fi + if test "$linkmode" = lib && + test "$hardcode_into_libs" = yes; then + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) compile_rpath="$compile_rpath $absdir" + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" + esac + ;; + esac + fi + + if test -n "$old_archive_from_expsyms_cmds"; then + # figure out the soname + set dummy $library_names + realname="$2" + shift; shift + libname=`eval \\$echo \"$libname_spec\"` + # use dlname if we got it. it's perfectly good, no? + if test -n "$dlname"; then + soname="$dlname" + elif test -n "$soname_spec"; then + # bleh windows + case $host in + *cygwin* | mingw*) + major=`expr $current - $age` + versuffix="-$major" + ;; + esac + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + + # Make a new name for the extract_expsyms_cmds to use + soroot="$soname" + soname=`$echo $soroot | ${SED} -e 's/^.*\///'` + newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a" + + # If the library has no export list, then create one now + if test -f "$output_objdir/$soname-def"; then : + else + $show "extracting exported symbol list from \`$soname'" + save_ifs="$IFS"; IFS='~' + cmds=$extract_expsyms_cmds + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + + # Create $newlib + if test -f "$output_objdir/$newlib"; then :; else + $show "generating import library for \`$soname'" + save_ifs="$IFS"; IFS='~' + cmds=$old_archive_from_expsyms_cmds + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + # make sure the library variables are pointing to the new library + dir=$output_objdir + linklib=$newlib + fi # test -n "$old_archive_from_expsyms_cmds" + + if test "$linkmode" = prog || test "$mode" != relink; then + add_shlibpath= + add_dir= + add= + lib_linked=yes + case $hardcode_action in + immediate | unsupported) + if test "$hardcode_direct" = no; then + add="$dir/$linklib" + case $host in + *-*-sco3.2v5* ) add_dir="-L$dir" ;; + *-*-darwin* ) + # if the lib is a module then we can not link against + # it, someone is ignoring the new warnings I added + if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then + $echo "** Warning, lib $linklib is a module, not a shared library" + if test -z "$old_library" ; then + $echo + $echo "** And there doesn't seem to be a static archive available" + $echo "** The link will probably fail, sorry" + else + add="$dir/$old_library" + fi + fi + esac + elif test "$hardcode_minus_L" = no; then + case $host in + *-*-sunos*) add_shlibpath="$dir" ;; + esac + add_dir="-L$dir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = no; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + relink) + if test "$hardcode_direct" = yes; then + add="$dir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$dir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case "$libdir" in + [\\/]*) + add_dir="$add_dir -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + *) lib_linked=no ;; + esac + + if test "$lib_linked" != yes; then + $echo "$modename: configuration error: unsupported hardcode properties" + exit $EXIT_FAILURE + fi + + if test -n "$add_shlibpath"; then + case :$compile_shlibpath: in + *":$add_shlibpath:"*) ;; + *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;; + esac + fi + if test "$linkmode" = prog; then + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" + test -n "$add" && compile_deplibs="$add $compile_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + if test "$hardcode_direct" != yes && \ + test "$hardcode_minus_L" != yes && \ + test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; + esac + fi + fi + fi + + if test "$linkmode" = prog || test "$mode" = relink; then + add_shlibpath= + add_dir= + add= + # Finalize command for both is simple: just hardcode it. + if test "$hardcode_direct" = yes; then + add="$libdir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$libdir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; + esac + add="-l$name" + elif test "$hardcode_automatic" = yes; then + if test -n "$inst_prefix_dir" && + test -f "$inst_prefix_dir$libdir/$linklib" ; then + add="$inst_prefix_dir$libdir/$linklib" + else + add="$libdir/$linklib" + fi + else + # We cannot seem to hardcode it, guess we'll fake it. + add_dir="-L$libdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case "$libdir" in + [\\/]*) + add_dir="$add_dir -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + fi + + if test "$linkmode" = prog; then + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" + test -n "$add" && finalize_deplibs="$add $finalize_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + fi + fi + elif test "$linkmode" = prog; then + # Here we assume that one of hardcode_direct or hardcode_minus_L + # is not unsupported. This is valid on all known static and + # shared platforms. + if test "$hardcode_direct" != unsupported; then + test -n "$old_library" && linklib="$old_library" + compile_deplibs="$dir/$linklib $compile_deplibs" + finalize_deplibs="$dir/$linklib $finalize_deplibs" + else + compile_deplibs="-l$name -L$dir $compile_deplibs" + finalize_deplibs="-l$name -L$dir $finalize_deplibs" + fi + elif test "$build_libtool_libs" = yes; then + # Not a shared library + if test "$deplibs_check_method" != pass_all; then + # We're trying link a shared library against a static one + # but the system doesn't support it. + + # Just print a warning and add the library to dependency_libs so + # that the program can be linked against the static library. + $echo + $echo "*** Warning: This system can not link to static lib archive $lib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have." + if test "$module" = yes; then + $echo "*** But as you try to build a module library, libtool will still create " + $echo "*** a static module, that should work as long as the dlopening application" + $echo "*** is linked with the -dlopen flag to resolve symbols at runtime." + if test -z "$global_symbol_pipe"; then + $echo + $echo "*** However, this would only work if libtool was able to extract symbol" + $echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + $echo "*** not find such a program. So, this module is probably useless." + $echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + else + convenience="$convenience $dir/$old_library" + old_convenience="$old_convenience $dir/$old_library" + deplibs="$dir/$old_library $deplibs" + link_static=yes + fi + fi # link shared/static library? + + if test "$linkmode" = lib; then + if test -n "$dependency_libs" && + { test "$hardcode_into_libs" != yes || + test "$build_old_libs" = yes || + test "$link_static" = yes; }; then + # Extract -R from dependency_libs + temp_deplibs= + for libdir in $dependency_libs; do + case $libdir in + -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'` + case " $xrpath " in + *" $temp_xrpath "*) ;; + *) xrpath="$xrpath $temp_xrpath";; + esac;; + *) temp_deplibs="$temp_deplibs $libdir";; + esac + done + dependency_libs="$temp_deplibs" + fi + + newlib_search_path="$newlib_search_path $absdir" + # Link against this library + test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" + # ... and its dependency_libs + tmp_libs= + for deplib in $dependency_libs; do + newdependency_libs="$deplib $newdependency_libs" + if test "X$duplicate_deps" = "Xyes" ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + tmp_libs="$tmp_libs $deplib" + done + + if test "$link_all_deplibs" != no; then + # Add the search paths of all dependency libraries + for deplib in $dependency_libs; do + case $deplib in + -L*) path="$deplib" ;; + *.la) + dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'` + test "X$dir" = "X$deplib" && dir="." + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2 + absdir="$dir" + fi + ;; + esac + if grep "^installed=no" $deplib > /dev/null; then + path="$absdir/$objdir" + else + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + if test -z "$libdir"; then + $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + if test "$absdir" != "$libdir"; then + $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2 + fi + path="$absdir" + fi + depdepl= + case $host in + *-*-darwin*) + # we do not want to link against static libs, + # but need to link against shared + eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` + if test -n "$deplibrary_names" ; then + for tmp in $deplibrary_names ; do + depdepl=$tmp + done + if test -f "$path/$depdepl" ; then + depdepl="$path/$depdepl" + fi + # do not add paths which are already there + case " $newlib_search_path " in + *" $path "*) ;; + *) newlib_search_path="$newlib_search_path $path";; + esac + fi + path="" + ;; + *) + path="-L$path" + ;; + esac + ;; + -l*) + case $host in + *-*-darwin*) + # Again, we only want to link against shared libraries + eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"` + for tmp in $newlib_search_path ; do + if test -f "$tmp/lib$tmp_libs.dylib" ; then + eval depdepl="$tmp/lib$tmp_libs.dylib" + break + fi + done + path="" + ;; + *) continue ;; + esac + ;; + *) continue ;; + esac + case " $deplibs " in + *" $depdepl "*) ;; + *) deplibs="$depdepl $deplibs" ;; + esac + case " $deplibs " in + *" $path "*) ;; + *) deplibs="$deplibs $path" ;; + esac + done + fi # link_all_deplibs != no + fi # linkmode = lib + done # for deplib in $libs + dependency_libs="$newdependency_libs" + if test "$pass" = dlpreopen; then + # Link the dlpreopened libraries before other libraries + for deplib in $save_deplibs; do + deplibs="$deplib $deplibs" + done + fi + if test "$pass" != dlopen; then + if test "$pass" != conv; then + # Make sure lib_search_path contains only unique directories. + lib_search_path= + for dir in $newlib_search_path; do + case "$lib_search_path " in + *" $dir "*) ;; + *) lib_search_path="$lib_search_path $dir" ;; + esac + done + newlib_search_path= + fi + + if test "$linkmode,$pass" != "prog,link"; then + vars="deplibs" + else + vars="compile_deplibs finalize_deplibs" + fi + for var in $vars dependency_libs; do + # Add libraries to $var in reverse order + eval tmp_libs=\"\$$var\" + new_libs= + for deplib in $tmp_libs; do + # FIXME: Pedantically, this is the right thing to do, so + # that some nasty dependency loop isn't accidentally + # broken: + #new_libs="$deplib $new_libs" + # Pragmatically, this seems to cause very few problems in + # practice: + case $deplib in + -L*) new_libs="$deplib $new_libs" ;; + -R*) ;; + *) + # And here is the reason: when a library appears more + # than once as an explicit dependence of a library, or + # is implicitly linked in more than once by the + # compiler, it is considered special, and multiple + # occurrences thereof are not removed. Compare this + # with having the same library being listed as a + # dependency of multiple other libraries: in this case, + # we know (pedantically, we assume) the library does not + # need to be listed more than once, so we keep only the + # last copy. This is not always right, but it is rare + # enough that we require users that really mean to play + # such unportable linking tricks to link the library + # using -Wl,-lname, so that libtool does not consider it + # for duplicate removal. + case " $specialdeplibs " in + *" $deplib "*) new_libs="$deplib $new_libs" ;; + *) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs="$deplib $new_libs" ;; + esac + ;; + esac + ;; + esac + done + tmp_libs= + for deplib in $new_libs; do + case $deplib in + -L*) + case " $tmp_libs " in + *" $deplib "*) ;; + *) tmp_libs="$tmp_libs $deplib" ;; + esac + ;; + *) tmp_libs="$tmp_libs $deplib" ;; + esac + done + eval $var=\"$tmp_libs\" + done # for var + fi + # Last step: remove runtime libs from dependency_libs + # (they stay in deplibs) + tmp_libs= + for i in $dependency_libs ; do + case " $predeps $postdeps $compiler_lib_search_path " in + *" $i "*) + i="" + ;; + esac + if test -n "$i" ; then + tmp_libs="$tmp_libs $i" + fi + done + dependency_libs=$tmp_libs + done # for pass + if test "$linkmode" = prog; then + dlfiles="$newdlfiles" + dlprefiles="$newdlprefiles" + fi + + case $linkmode in + oldlib) + if test -n "$deplibs"; then + $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 + fi + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2 + fi + + if test -n "$rpath"; then + $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2 + fi + + if test -n "$xrpath"; then + $echo "$modename: warning: \`-R' is ignored for archives" 1>&2 + fi + + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for archives" 1>&2 + fi + + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2 + fi + + # Now set the variables for building old libraries. + build_libtool_libs=no + oldlibs="$output" + objs="$objs$old_deplibs" + ;; + + lib) + # Make sure we only generate libraries of the form `libNAME.la'. + case $outputname in + lib*) + name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'` + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + ;; + *) + if test "$module" = no; then + $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + if test "$need_lib_prefix" != no; then + # Add the "lib" prefix for modules if required + name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'` + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + else + libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'` + fi + ;; + esac + + if test -n "$objs"; then + if test "$deplibs_check_method" != pass_all; then + $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1 + exit $EXIT_FAILURE + else + $echo + $echo "*** Warning: Linking the shared library $output against the non-libtool" + $echo "*** objects $objs is not portable!" + libobjs="$libobjs $objs" + fi + fi + + if test "$dlself" != no; then + $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2 + fi + + set dummy $rpath + if test "$#" -gt 2; then + $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2 + fi + install_libdir="$2" + + oldlibs= + if test -z "$rpath"; then + if test "$build_libtool_libs" = yes; then + # Building a libtool convenience library. + # Some compilers have problems with a `.al' extension so + # convenience libraries should have the same extension an + # archive normally would. + oldlibs="$output_objdir/$libname.$libext $oldlibs" + build_libtool_libs=convenience + build_old_libs=yes + fi + + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2 + fi + else + + # Parse the version information argument. + save_ifs="$IFS"; IFS=':' + set dummy $vinfo 0 0 0 + IFS="$save_ifs" + + if test -n "$8"; then + $echo "$modename: too many parameters to \`-version-info'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # convert absolute version numbers to libtool ages + # this retains compatibility with .la files and attempts + # to make the code below a bit more comprehensible + + case $vinfo_number in + yes) + number_major="$2" + number_minor="$3" + number_revision="$4" + # + # There are really only two kinds -- those that + # use the current revision as the major version + # and those that subtract age and use age as + # a minor version. But, then there is irix + # which has an extra 1 added just for fun + # + case $version_type in + darwin|linux|osf|windows) + current=`expr $number_major + $number_minor` + age="$number_minor" + revision="$number_revision" + ;; + freebsd-aout|freebsd-elf|sunos) + current="$number_major" + revision="$number_minor" + age="0" + ;; + irix|nonstopux) + current=`expr $number_major + $number_minor - 1` + age="$number_minor" + revision="$number_minor" + ;; + esac + ;; + no) + current="$2" + revision="$3" + age="$4" + ;; + esac + + # Check that each of the things are valid numbers. + case $current in + [0-9]*) ;; + *) + $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + case $revision in + [0-9]*) ;; + *) + $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + case $age in + [0-9]*) ;; + *) + $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + if test "$age" -gt "$current"; then + $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + fi + + # Calculate the version variables. + major= + versuffix= + verstring= + case $version_type in + none) ;; + + darwin) + # Like Linux, but with the current version available in + # verstring for coding it into the library header + major=.`expr $current - $age` + versuffix="$major.$age.$revision" + # Darwin ld doesn't like 0 for these options... + minor_current=`expr $current + 1` + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" + ;; + + freebsd-aout) + major=".$current" + versuffix=".$current.$revision"; + ;; + + freebsd-elf) + major=".$current" + versuffix=".$current"; + ;; + + irix | nonstopux) + major=`expr $current - $age + 1` + + case $version_type in + nonstopux) verstring_prefix=nonstopux ;; + *) verstring_prefix=sgi ;; + esac + verstring="$verstring_prefix$major.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$revision + while test "$loop" -ne 0; do + iface=`expr $revision - $loop` + loop=`expr $loop - 1` + verstring="$verstring_prefix$major.$iface:$verstring" + done + + # Before this point, $major must not contain `.'. + major=.$major + versuffix="$major.$revision" + ;; + + linux) + major=.`expr $current - $age` + versuffix="$major.$age.$revision" + ;; + + osf) + major=.`expr $current - $age` + versuffix=".$current.$age.$revision" + verstring="$current.$age.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$age + while test "$loop" -ne 0; do + iface=`expr $current - $loop` + loop=`expr $loop - 1` + verstring="$verstring:${iface}.0" + done + + # Make executables depend on our current version. + verstring="$verstring:${current}.0" + ;; + + sunos) + major=".$current" + versuffix=".$current.$revision" + ;; + + windows) + # Use '-' rather than '.', since we only want one + # extension on DOS 8.3 filesystems. + major=`expr $current - $age` + versuffix="-$major" + ;; + + *) + $echo "$modename: unknown library version type \`$version_type'" 1>&2 + $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 + exit $EXIT_FAILURE + ;; + esac + + # Clear the version info if we defaulted, and they specified a release. + if test -z "$vinfo" && test -n "$release"; then + major= + case $version_type in + darwin) + # we can't check for "0.0" in archive_cmds due to quoting + # problems, so we reset it completely + verstring= + ;; + *) + verstring="0.0" + ;; + esac + if test "$need_version" = no; then + versuffix= + else + versuffix=".0.0" + fi + fi + + # Remove version info from name if versioning should be avoided + if test "$avoid_version" = yes && test "$need_version" = no; then + major= + versuffix= + verstring="" + fi + + # Check to see if the archive will have undefined symbols. + if test "$allow_undefined" = yes; then + if test "$allow_undefined_flag" = unsupported; then + $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2 + build_libtool_libs=no + build_old_libs=yes + fi + else + # Don't allow undefined symbols. + allow_undefined_flag="$no_undefined_flag" + fi + fi + + if test "$mode" != relink; then + # Remove our outputs, but don't remove object files since they + # may have been created when compiling PIC objects. + removelist= + tempremovelist=`$echo "$output_objdir/*"` + for p in $tempremovelist; do + case $p in + *.$objext) + ;; + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) + if test "X$precious_files_regex" != "X"; then + if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 + then + continue + fi + fi + removelist="$removelist $p" + ;; + *) ;; + esac + done + if test -n "$removelist"; then + $show "${rm}r $removelist" + $run ${rm}r $removelist + fi + fi + + # Now set the variables for building old libraries. + if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then + oldlibs="$oldlibs $output_objdir/$libname.$libext" + + # Transform .lo files to .o files. + oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP` + fi + + # Eliminate all temporary directories. + for path in $notinst_path; do + lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'` + deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'` + dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'` + done + + if test -n "$xrpath"; then + # If the user specified any rpath flags, then add them. + temp_xrpath= + for libdir in $xrpath; do + temp_xrpath="$temp_xrpath -R$libdir" + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" ;; + esac + done + if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then + dependency_libs="$temp_xrpath $dependency_libs" + fi + fi + + # Make sure dlfiles contains only unique files that won't be dlpreopened + old_dlfiles="$dlfiles" + dlfiles= + for lib in $old_dlfiles; do + case " $dlprefiles $dlfiles " in + *" $lib "*) ;; + *) dlfiles="$dlfiles $lib" ;; + esac + done + + # Make sure dlprefiles contains only unique files + old_dlprefiles="$dlprefiles" + dlprefiles= + for lib in $old_dlprefiles; do + case "$dlprefiles " in + *" $lib "*) ;; + *) dlprefiles="$dlprefiles $lib" ;; + esac + done + + if test "$build_libtool_libs" = yes; then + if test -n "$rpath"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*) + # these systems don't actually have a c library (as such)! + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C library is in the System framework + deplibs="$deplibs -framework System" + ;; + *-*-netbsd*) + # Don't link with libc until the a.out ld.so is fixed. + ;; + *-*-openbsd* | *-*-freebsd*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *) + # Add libc to deplibs on all other systems if necessary. + if test "$build_libtool_need_lc" = "yes"; then + deplibs="$deplibs -lc" + fi + ;; + esac + fi + + # Transform deplibs into only deplibs that can be linked in shared. + name_save=$name + libname_save=$libname + release_save=$release + versuffix_save=$versuffix + major_save=$major + # I'm not sure if I'm treating the release correctly. I think + # release should show up in the -l (ie -lgmp5) so we don't want to + # add it in twice. Is that correct? + release="" + versuffix="" + major="" + newdeplibs= + droppeddeps=no + case $deplibs_check_method in + pass_all) + # Don't check for shared/static. Everything works. + # This might be a little naive. We might want to check + # whether the library exists or not. But this is on + # osf3 & osf4 and I'm not really sure... Just + # implementing what was already the behavior. + newdeplibs=$deplibs + ;; + test_compile) + # This code stresses the "libraries are programs" paradigm to its + # limits. Maybe even breaks it. We compile a program, linking it + # against the deplibs as a proxy for the library. Then we can check + # whether they linked in statically or dynamically with ldd. + $rm conftest.c + cat > conftest.c </dev/null` + for potent_lib in $potential_libs; do + # Follow soft links. + if ls -lLd "$potent_lib" 2>/dev/null \ + | grep " -> " >/dev/null; then + continue + fi + # The statement above tries to avoid entering an + # endless loop below, in case of cyclic links. + # We might still enter an endless loop, since a link + # loop can be closed while we follow links, + # but so what? + potlib="$potent_lib" + while test -h "$potlib" 2>/dev/null; do + potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` + case $potliblink in + [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; + *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";; + esac + done + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \ + | ${SED} 10q \ + | $EGREP "$file_magic_regex" > /dev/null; then + newdeplibs="$newdeplibs $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + $echo + $echo "*** Warning: linker path does not have real file for library $a_deplib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have" + $echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $echo "*** with $libname but no candidates were found. (...for file magic test)" + else + $echo "*** with $libname and none of the candidates passed a file format test" + $echo "*** using a file magic. Last file checked: $potlib" + fi + fi + else + # Add a -L argument. + newdeplibs="$newdeplibs $a_deplib" + fi + done # Gone through all deplibs. + ;; + match_pattern*) + set dummy $deplibs_check_method + match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"` + for a_deplib in $deplibs; do + name="`expr $a_deplib : '-l\(.*\)'`" + # If $name is empty we are operating on a -L argument. + if test -n "$name" && test "$name" != "0"; then + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $a_deplib "*) + newdeplibs="$newdeplibs $a_deplib" + a_deplib="" + ;; + esac + fi + if test -n "$a_deplib" ; then + libname=`eval \\$echo \"$libname_spec\"` + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do + potential_libs=`ls $i/$libname[.-]* 2>/dev/null` + for potent_lib in $potential_libs; do + potlib="$potent_lib" # see symlink-check above in file_magic test + if eval $echo \"$potent_lib\" 2>/dev/null \ + | ${SED} 10q \ + | $EGREP "$match_pattern_regex" > /dev/null; then + newdeplibs="$newdeplibs $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + $echo + $echo "*** Warning: linker path does not have real file for library $a_deplib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have" + $echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $echo "*** with $libname but no candidates were found. (...for regex pattern test)" + else + $echo "*** with $libname and none of the candidates passed a file format test" + $echo "*** using a regex pattern. Last file checked: $potlib" + fi + fi + else + # Add a -L argument. + newdeplibs="$newdeplibs $a_deplib" + fi + done # Gone through all deplibs. + ;; + none | unknown | *) + newdeplibs="" + tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \ + -e 's/ -[LR][^ ]*//g'` + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + for i in $predeps $postdeps ; do + # can't use Xsed below, because $i might contain '/' + tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"` + done + fi + if $echo "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' \ + | grep . >/dev/null; then + $echo + if test "X$deplibs_check_method" = "Xnone"; then + $echo "*** Warning: inter-library dependencies are not supported in this platform." + else + $echo "*** Warning: inter-library dependencies are not known to be supported." + fi + $echo "*** All declared inter-library dependencies are being dropped." + droppeddeps=yes + fi + ;; + esac + versuffix=$versuffix_save + major=$major_save + release=$release_save + libname=$libname_save + name=$name_save + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'` + ;; + esac + + if test "$droppeddeps" = yes; then + if test "$module" = yes; then + $echo + $echo "*** Warning: libtool could not satisfy all declared inter-library" + $echo "*** dependencies of module $libname. Therefore, libtool will create" + $echo "*** a static module, that should work as long as the dlopening" + $echo "*** application is linked with the -dlopen flag." + if test -z "$global_symbol_pipe"; then + $echo + $echo "*** However, this would only work if libtool was able to extract symbol" + $echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + $echo "*** not find such a program. So, this module is probably useless." + $echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + else + $echo "*** The inter-library dependencies that have been dropped here will be" + $echo "*** automatically added whenever a program is linked with this library" + $echo "*** or is declared to -dlopen it." + + if test "$allow_undefined" = no; then + $echo + $echo "*** Since this library must not contain undefined symbols," + $echo "*** because either the platform does not support them or" + $echo "*** it was explicitly requested with -no-undefined," + $echo "*** libtool will only create a static version of it." + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + fi + fi + # Done checking deplibs! + deplibs=$newdeplibs + fi + + # All the library-specific variables (install_libdir is set above). + library_names= + old_library= + dlname= + + # Test again, we may have decided not to build it any more + if test "$build_libtool_libs" = yes; then + if test "$hardcode_into_libs" = yes; then + # Hardcode the library paths + hardcode_libdirs= + dep_rpath= + rpath="$finalize_rpath" + test "$mode" != relink && rpath="$compile_rpath$rpath" + for libdir in $rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + dep_rpath="$dep_rpath $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) perm_rpath="$perm_rpath $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + if test -n "$hardcode_libdir_flag_spec_ld"; then + eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" + else + eval dep_rpath=\"$hardcode_libdir_flag_spec\" + fi + fi + if test -n "$runpath_var" && test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + rpath="$rpath$dir:" + done + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" + fi + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" + fi + + shlibpath="$finalize_shlibpath" + test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath" + if test -n "$shlibpath"; then + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" + fi + + # Get the real and link names of the library. + eval shared_ext=\"$shrext_cmds\" + eval library_names=\"$library_names_spec\" + set dummy $library_names + realname="$2" + shift; shift + + if test -n "$soname_spec"; then + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + if test -z "$dlname"; then + dlname=$soname + fi + + lib="$output_objdir/$realname" + for link + do + linknames="$linknames $link" + done + + # Use standard objects if they are pic + test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then + $show "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $run $rm $export_symbols + cmds=$export_symbols_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + if len=`expr "X$cmd" : ".*"` && + test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then + $show "$cmd" + $run eval "$cmd" || exit $? + skipped_export=false + else + # The command line is too long to execute in one step. + $show "using reloadable object file for export list..." + skipped_export=: + fi + done + IFS="$save_ifs" + if test -n "$export_symbols_regex"; then + $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\"" + $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + $show "$mv \"${export_symbols}T\" \"$export_symbols\"" + $run eval '$mv "${export_symbols}T" "$export_symbols"' + fi + fi + fi + + if test -n "$export_symbols" && test -n "$include_expsyms"; then + $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"' + fi + + tmp_deplibs= + inst_prefix_arg= + for test_deplib in $deplibs; do + case " $convenience " in + *" $test_deplib "*) ;; + *) + if test -n "$inst_prefix_dir" && (echo "$test_deplib" | grep -- "$inst_prefix_dir" >/dev/null); then + inst_prefix_arg="$test_deplib" + else + tmp_deplibs="$tmp_deplibs $test_deplib" + fi + ;; + esac + done + deplibs="$tmp_deplibs" + if test -n "$inst_prefix_arg"; then + deplibs="$inst_prefix_arg $deplibs" + fi + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + else + gentop="$output_objdir/${outputname}x" + $show "${rm}r $gentop" + $run ${rm}r "$gentop" + $show "$mkdir $gentop" + $run $mkdir "$gentop" + status=$? + if test "$status" -ne 0 && test ! -d "$gentop"; then + exit $status + fi + generated="$generated $gentop" + + for xlib in $convenience; do + # Extract the objects. + case $xlib in + [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;; + *) xabs=`pwd`"/$xlib" ;; + esac + xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'` + xdir="$gentop/$xlib" + + $show "${rm}r $xdir" + $run ${rm}r "$xdir" + $show "$mkdir $xdir" + $run $mkdir "$xdir" + status=$? + if test "$status" -ne 0 && test ! -d "$xdir"; then + exit $status + fi + # We will extract separately just the conflicting names and we will no + # longer touch any unique names. It is faster to leave these extract + # automatically by $AR in one run. + $show "(cd $xdir && $AR x $xabs)" + $run eval "(cd \$xdir && $AR x \$xabs)" || exit $? + if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; renaming object files" 1>&2 + $echo "$modename: warning: to ensure that they will not overwrite" 1>&2 + $AR t "$xabs" | sort | uniq -cd | while read -r count name + do + i=1 + while test "$i" -le "$count" + do + # Put our $i before any first dot (extension) + # Never overwrite any file + name_to="$name" + while test "X$name_to" = "X$name" || test -f "$xdir/$name_to" + do + name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"` + done + $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')" + $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $? + i=`expr $i + 1` + done + done + fi + + libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP` + done + fi + fi + + if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then + eval flag=\"$thread_safe_flag_spec\" + linker_flags="$linker_flags $flag" + fi + + # Make a backup of the uninstalled library when relinking + if test "$mode" = relink; then + $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $? + fi + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + eval test_cmds=\"$module_expsym_cmds\" + cmds=$module_expsym_cmds + else + eval test_cmds=\"$module_cmds\" + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + eval test_cmds=\"$archive_expsym_cmds\" + cmds=$archive_expsym_cmds + else + eval test_cmds=\"$archive_cmds\" + cmds=$archive_cmds + fi + fi + + if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` && + test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then + : + else + # The command line is too long to link in one step, link piecewise. + $echo "creating reloadable object files..." + + # Save the value of $output and $libobjs because we want to + # use them later. If we have whole_archive_flag_spec, we + # want to use save_libobjs as it was before + # whole_archive_flag_spec was expanded, because we can't + # assume the linker understands whole_archive_flag_spec. + # This may have to be revisited, in case too many + # convenience libraries get linked in and end up exceeding + # the spec. + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + fi + save_output=$output + + # Clear the reloadable object creation command queue and + # initialize k to one. + test_cmds= + concat_cmds= + objlist= + delfiles= + last_robj= + k=1 + output=$output_objdir/$save_output-${k}.$objext + # Loop over the list of objects to be linked. + for obj in $save_libobjs + do + eval test_cmds=\"$reload_cmds $objlist $last_robj\" + if test "X$objlist" = X || + { len=`expr "X$test_cmds" : ".*"` && + test "$len" -le "$max_cmd_len"; }; then + objlist="$objlist $obj" + else + # The command $test_cmds is almost too long, add a + # command to the queue. + if test "$k" -eq 1 ; then + # The first file doesn't have a previous command to add. + eval concat_cmds=\"$reload_cmds $objlist $last_robj\" + else + # All subsequent reloadable object files will link in + # the last one created. + eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\" + fi + last_robj=$output_objdir/$save_output-${k}.$objext + k=`expr $k + 1` + output=$output_objdir/$save_output-${k}.$objext + objlist=$obj + len=1 + fi + done + # Handle the remaining objects by creating one last + # reloadable object file. All subsequent reloadable object + # files will link in the last one created. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\" + + if ${skipped_export-false}; then + $show "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $run $rm $export_symbols + libobjs=$output + # Append the command to create the export file. + eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\" + fi + + # Set up a command to remove the reloadale object files + # after they are used. + i=0 + while test "$i" -lt "$k" + do + i=`expr $i + 1` + delfiles="$delfiles $output_objdir/$save_output-${i}.$objext" + done + + $echo "creating a temporary reloadable object file: $output" + + # Loop through the commands generated above and execute them. + save_ifs="$IFS"; IFS='~' + for cmd in $concat_cmds; do + IFS="$save_ifs" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + + libobjs=$output + # Restore the value of output. + output=$save_output + + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + fi + # Expand the library linking commands again to reset the + # value of $libobjs for piecewise linking. + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + cmds=$module_expsym_cmds + else + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + cmds=$archive_expsym_cmds + else + cmds=$archive_cmds + fi + fi + + # Append the command to remove the reloadable object files + # to the just-reset $cmds. + eval cmds=\"\$cmds~\$rm $delfiles\" + fi + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + + # Restore the uninstalled library and exit + if test "$mode" = relink; then + $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $? + exit $EXIT_SUCCESS + fi + + # Create links to the real library. + for linkname in $linknames; do + if test "$realname" != "$linkname"; then + $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)" + $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $? + fi + done + + # If -module or -export-dynamic was specified, set the dlname. + if test "$module" = yes || test "$export_dynamic" = yes; then + # On all known operating systems, these are identical. + dlname="$soname" + fi + fi + ;; + + obj) + if test -n "$deplibs"; then + $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 + fi + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2 + fi + + if test -n "$rpath"; then + $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2 + fi + + if test -n "$xrpath"; then + $echo "$modename: warning: \`-R' is ignored for objects" 1>&2 + fi + + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for objects" 1>&2 + fi + + case $output in + *.lo) + if test -n "$objs$old_deplibs"; then + $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2 + exit $EXIT_FAILURE + fi + libobj="$output" + obj=`$echo "X$output" | $Xsed -e "$lo2o"` + ;; + *) + libobj= + obj="$output" + ;; + esac + + # Delete the old objects. + $run $rm $obj $libobj + + # Objects from convenience libraries. This assumes + # single-version convenience libraries. Whenever we create + # different ones for PIC/non-PIC, this we'll have to duplicate + # the extraction. + reload_conv_objs= + gentop= + # reload_cmds runs $LD directly, so let us get rid of + # -Wl from whole_archive_flag_spec + wl= + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\" + else + gentop="$output_objdir/${obj}x" + $show "${rm}r $gentop" + $run ${rm}r "$gentop" + $show "$mkdir $gentop" + $run $mkdir "$gentop" + status=$? + if test "$status" -ne 0 && test ! -d "$gentop"; then + exit $status + fi + generated="$generated $gentop" + + for xlib in $convenience; do + # Extract the objects. + case $xlib in + [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;; + *) xabs=`pwd`"/$xlib" ;; + esac + xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'` + xdir="$gentop/$xlib" + + $show "${rm}r $xdir" + $run ${rm}r "$xdir" + $show "$mkdir $xdir" + $run $mkdir "$xdir" + status=$? + if test "$status" -ne 0 && test ! -d "$xdir"; then + exit $status + fi + # We will extract separately just the conflicting names and we will no + # longer touch any unique names. It is faster to leave these extract + # automatically by $AR in one run. + $show "(cd $xdir && $AR x $xabs)" + $run eval "(cd \$xdir && $AR x \$xabs)" || exit $? + if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; renaming object files" 1>&2 + $echo "$modename: warning: to ensure that they will not overwrite" 1>&2 + $AR t "$xabs" | sort | uniq -cd | while read -r count name + do + i=1 + while test "$i" -le "$count" + do + # Put our $i before any first dot (extension) + # Never overwrite any file + name_to="$name" + while test "X$name_to" = "X$name" || test -f "$xdir/$name_to" + do + name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"` + done + $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')" + $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $? + i=`expr $i + 1` + done + done + fi + + reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP` + done + fi + fi + + # Create the old-style object. + reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test + + output="$obj" + cmds=$reload_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + + # Exit if we aren't doing a library object file. + if test -z "$libobj"; then + if test -n "$gentop"; then + $show "${rm}r $gentop" + $run ${rm}r $gentop + fi + + exit $EXIT_SUCCESS + fi + + if test "$build_libtool_libs" != yes; then + if test -n "$gentop"; then + $show "${rm}r $gentop" + $run ${rm}r $gentop + fi + + # Create an invalid libtool object if no PIC, so that we don't + # accidentally link it into a program. + # $show "echo timestamp > $libobj" + # $run eval "echo timestamp > $libobj" || exit $? + exit $EXIT_SUCCESS + fi + + if test -n "$pic_flag" || test "$pic_mode" != default; then + # Only do commands if we really have different PIC objects. + reload_objs="$libobjs $reload_conv_objs" + output="$libobj" + cmds=$reload_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + + if test -n "$gentop"; then + $show "${rm}r $gentop" + $run ${rm}r $gentop + fi + + exit $EXIT_SUCCESS + ;; + + prog) + case $host in + *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;; + esac + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for programs" 1>&2 + fi + + if test "$preload" = yes; then + if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown && + test "$dlopen_self_static" = unknown; then + $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support." + fi + fi + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'` + finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'` + ;; + esac + + case $host in + *darwin*) + # Don't allow lazy linking, it breaks C++ global constructors + if test "$tagname" = CXX ; then + compile_command="$compile_command ${wl}-bind_at_load" + finalize_command="$finalize_command ${wl}-bind_at_load" + fi + ;; + esac + + compile_command="$compile_command $compile_deplibs" + finalize_command="$finalize_command $finalize_deplibs" + + if test -n "$rpath$xrpath"; then + # If the user specified any rpath flags, then add them. + for libdir in $rpath $xrpath; do + # This is the magic to use -rpath. + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" ;; + esac + done + fi + + # Now hardcode the library paths + rpath= + hardcode_libdirs= + for libdir in $compile_rpath $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + rpath="$rpath $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) perm_rpath="$perm_rpath $libdir" ;; + esac + fi + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) + case :$dllsearchpath: in + *":$libdir:"*) ;; + *) dllsearchpath="$dllsearchpath:$libdir";; + esac + ;; + esac + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + compile_rpath="$rpath" + + rpath= + hardcode_libdirs= + for libdir in $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + rpath="$rpath $flag" + fi + elif test -n "$runpath_var"; then + case "$finalize_perm_rpath " in + *" $libdir "*) ;; + *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + finalize_rpath="$rpath" + + if test -n "$libobjs" && test "$build_old_libs" = yes; then + # Transform all the library objects into standard objects. + compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + fi + + dlsyms= + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + if test -n "$NM" && test -n "$global_symbol_pipe"; then + dlsyms="${outputname}S.c" + else + $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2 + fi + fi + + if test -n "$dlsyms"; then + case $dlsyms in + "") ;; + *.c) + # Discover the nlist of each of the dlfiles. + nlist="$output_objdir/${outputname}.nm" + + $show "$rm $nlist ${nlist}S ${nlist}T" + $run $rm "$nlist" "${nlist}S" "${nlist}T" + + # Parse the name list into a source file. + $show "creating $output_objdir/$dlsyms" + + test -z "$run" && $echo > "$output_objdir/$dlsyms" "\ +/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */ +/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */ + +#ifdef __cplusplus +extern \"C\" { +#endif + +/* Prevent the only kind of declaration conflicts we can make. */ +#define lt_preloaded_symbols some_other_symbol + +/* External symbol declarations for the compiler. */\ +" + + if test "$dlself" = yes; then + $show "generating symbol list for \`$output'" + + test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist" + + # Add our own program objects to the symbol list. + progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + for arg in $progfiles; do + $show "extracting global C symbols from \`$arg'" + $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'" + done + + if test -n "$exclude_expsyms"; then + $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' + $run eval '$mv "$nlist"T "$nlist"' + fi + + if test -n "$export_symbols_regex"; then + $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' + $run eval '$mv "$nlist"T "$nlist"' + fi + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + export_symbols="$output_objdir/$output.exp" + $run $rm $export_symbols + $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' + else + $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"' + $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T' + $run eval 'mv "$nlist"T "$nlist"' + fi + fi + + for arg in $dlprefiles; do + $show "extracting global C symbols from \`$arg'" + name=`$echo "$arg" | ${SED} -e 's%^.*/%%'` + $run eval '$echo ": $name " >> "$nlist"' + $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'" + done + + if test -z "$run"; then + # Make sure we have at least an empty file. + test -f "$nlist" || : > "$nlist" + + if test -n "$exclude_expsyms"; then + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T + $mv "$nlist"T "$nlist" + fi + + # Try sorting and uniquifying the output. + if grep -v "^: " < "$nlist" | + if sort -k 3 /dev/null 2>&1; then + sort -k 3 + else + sort +2 + fi | + uniq > "$nlist"S; then + : + else + grep -v "^: " < "$nlist" > "$nlist"S + fi + + if test -f "$nlist"S; then + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"' + else + $echo '/* NONE */' >> "$output_objdir/$dlsyms" + fi + + $echo >> "$output_objdir/$dlsyms" "\ + +#undef lt_preloaded_symbols + +#if defined (__STDC__) && __STDC__ +# define lt_ptr void * +#else +# define lt_ptr char * +# define const +#endif + +/* The mapping between symbol names and symbols. */ +const struct { + const char *name; + lt_ptr address; +} +lt_preloaded_symbols[] = +{\ +" + + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms" + + $echo >> "$output_objdir/$dlsyms" "\ + {0, (lt_ptr) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif\ +" + fi + + pic_flag_for_symtable= + case $host in + # compiling the symbol table file with pic_flag works around + # a FreeBSD bug that causes programs to crash when -lm is + # linked before any other PIC object. But we must not use + # pic_flag when linking with -static. The problem exists in + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. + *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) + case "$compile_command " in + *" -static "*) ;; + *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";; + esac;; + *-*-hpux*) + case "$compile_command " in + *" -static "*) ;; + *) pic_flag_for_symtable=" $pic_flag";; + esac + esac + + # Now compile the dynamic symbol file. + $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")" + $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $? + + # Clean up the generated files. + $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T" + $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T" + + # Transform the symbol file into the correct name. + compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"` + finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"` + ;; + *) + $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2 + exit $EXIT_FAILURE + ;; + esac + else + # We keep going just in case the user didn't refer to + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe + # really was required. + + # Nullify the symbol file. + compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"` + finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"` + fi + + if test "$need_relink" = no || test "$build_libtool_libs" != yes; then + # Replace the output file specification. + compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` + link_command="$compile_command$compile_rpath" + + # We have no uninstalled library dependencies, so finalize right now. + $show "$link_command" + $run eval "$link_command" + status=$? + + # Delete the generated files. + if test -n "$dlsyms"; then + $show "$rm $output_objdir/${outputname}S.${objext}" + $run $rm "$output_objdir/${outputname}S.${objext}" + fi + + exit $status + fi + + if test -n "$shlibpath_var"; then + # We should set the shlibpath_var + rpath= + for dir in $temp_rpath; do + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) + # Absolute path. + rpath="$rpath$dir:" + ;; + *) + # Relative path: add a thisdir entry. + rpath="$rpath\$thisdir/$dir:" + ;; + esac + done + temp_rpath="$rpath" + fi + + if test -n "$compile_shlibpath$finalize_shlibpath"; then + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" + fi + if test -n "$finalize_shlibpath"; then + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" + fi + + compile_var= + finalize_var= + if test -n "$runpath_var"; then + if test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + rpath="$rpath$dir:" + done + compile_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + if test -n "$finalize_perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $finalize_perm_rpath; do + rpath="$rpath$dir:" + done + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + fi + + if test "$no_install" = yes; then + # We don't need to create a wrapper script. + link_command="$compile_var$compile_command$compile_rpath" + # Replace the output file specification. + link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` + # Delete the old output file. + $run $rm $output + # Link the executable and exit + $show "$link_command" + $run eval "$link_command" || exit $? + exit $EXIT_SUCCESS + fi + + if test "$hardcode_action" = relink; then + # Fast installation is not supported + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + + $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2 + $echo "$modename: \`$output' will be relinked during installation" 1>&2 + else + if test "$fast_install" != no; then + link_command="$finalize_var$compile_command$finalize_rpath" + if test "$fast_install" = yes; then + relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'` + else + # fast_install is set to needless + relink_command= + fi + else + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + fi + fi + + # Replace the output file specification. + link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` + + # Delete the old output files. + $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname + + $show "$link_command" + $run eval "$link_command" || exit $? + + # Now create the wrapper script. + $show "creating $output" + + # Quote the relink command for shipping. + if test -n "$relink_command"; then + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"` + relink_command="$var=\"$var_value\"; export $var; $relink_command" + fi + done + relink_command="(cd `pwd`; $relink_command)" + relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"` + fi + + # Quote $echo for shipping. + if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then + case $progpath in + [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";; + *) qecho="$SHELL `pwd`/$progpath --fallback-echo";; + esac + qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"` + else + qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"` + fi + + # Only actually do things if our run command is non-null. + if test -z "$run"; then + # win32 will think the script is a binary if it has + # a .exe suffix, so we strip it off here. + case $output in + *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;; + esac + # test for cygwin because mv fails w/o .exe extensions + case $host in + *cygwin*) + exeext=.exe + outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;; + *) exeext= ;; + esac + case $host in + *cygwin* | *mingw* ) + cwrappersource=`$echo ${objdir}/lt-${output}.c` + cwrapper=`$echo ${output}.exe` + $rm $cwrappersource $cwrapper + trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 + + cat > $cwrappersource <> $cwrappersource<<"EOF" +#include +#include +#include +#include +#include +#include + +#if defined(PATH_MAX) +# define LT_PATHMAX PATH_MAX +#elif defined(MAXPATHLEN) +# define LT_PATHMAX MAXPATHLEN +#else +# define LT_PATHMAX 1024 +#endif + +#ifndef DIR_SEPARATOR +#define DIR_SEPARATOR '/' +#endif + +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ + defined (__OS2__) +#define HAVE_DOS_BASED_FILE_SYSTEM +#ifndef DIR_SEPARATOR_2 +#define DIR_SEPARATOR_2 '\\' +#endif +#endif + +#ifndef DIR_SEPARATOR_2 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) +#else /* DIR_SEPARATOR_2 */ +# define IS_DIR_SEPARATOR(ch) \ + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) +#endif /* DIR_SEPARATOR_2 */ + +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) +#define XFREE(stale) do { \ + if (stale) { free ((void *) stale); stale = 0; } \ +} while (0) + +const char *program_name = NULL; + +void * xmalloc (size_t num); +char * xstrdup (const char *string); +char * basename (const char *name); +char * fnqualify(const char *path); +char * strendzap(char *str, const char *pat); +void lt_fatal (const char *message, ...); + +int +main (int argc, char *argv[]) +{ + char **newargz; + int i; + + program_name = (char *) xstrdup ((char *) basename (argv[0])); + newargz = XMALLOC(char *, argc+2); +EOF + + cat >> $cwrappersource <> $cwrappersource <<"EOF" + newargz[1] = fnqualify(argv[0]); + /* we know the script has the same name, without the .exe */ + /* so make sure newargz[1] doesn't end in .exe */ + strendzap(newargz[1],".exe"); + for (i = 1; i < argc; i++) + newargz[i+1] = xstrdup(argv[i]); + newargz[argc+1] = NULL; +EOF + + cat >> $cwrappersource <> $cwrappersource <<"EOF" +} + +void * +xmalloc (size_t num) +{ + void * p = (void *) malloc (num); + if (!p) + lt_fatal ("Memory exhausted"); + + return p; +} + +char * +xstrdup (const char *string) +{ + return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL +; +} + +char * +basename (const char *name) +{ + const char *base; + +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + /* Skip over the disk name in MSDOS pathnames. */ + if (isalpha (name[0]) && name[1] == ':') + name += 2; +#endif + + for (base = name; *name; name++) + if (IS_DIR_SEPARATOR (*name)) + base = name + 1; + return (char *) base; +} + +char * +fnqualify(const char *path) +{ + size_t size; + char *p; + char tmp[LT_PATHMAX + 1]; + + assert(path != NULL); + + /* Is it qualified already? */ +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + if (isalpha (path[0]) && path[1] == ':') + return xstrdup (path); +#endif + if (IS_DIR_SEPARATOR (path[0])) + return xstrdup (path); + + /* prepend the current directory */ + /* doesn't handle '~' */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal ("getcwd failed"); + size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */ + p = XMALLOC(char, size); + sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path); + return p; +} + +char * +strendzap(char *str, const char *pat) +{ + size_t len, patlen; + + assert(str != NULL); + assert(pat != NULL); + + len = strlen(str); + patlen = strlen(pat); + + if (patlen <= len) + { + str += len - patlen; + if (strcmp(str, pat) == 0) + *str = '\0'; + } + return str; +} + +static void +lt_error_core (int exit_status, const char * mode, + const char * message, va_list ap) +{ + fprintf (stderr, "%s: %s: ", program_name, mode); + vfprintf (stderr, message, ap); + fprintf (stderr, ".\n"); + + if (exit_status >= 0) + exit (exit_status); +} + +void +lt_fatal (const char *message, ...) +{ + va_list ap; + va_start (ap, message); + lt_error_core (EXIT_FAILURE, "FATAL", message, ap); + va_end (ap); +} +EOF + # we should really use a build-platform specific compiler + # here, but OTOH, the wrappers (shell script and this C one) + # are only useful if you want to execute the "real" binary. + # Since the "real" binary is built for $host, then this + # wrapper might as well be built for $host, too. + $run $LTCC -s -o $cwrapper $cwrappersource + ;; + esac + $rm $output + trap "$rm $output; exit $EXIT_FAILURE" 1 2 15 + + $echo > $output "\ +#! $SHELL + +# $output - temporary wrapper script for $objdir/$outputname +# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP +# +# The $output program cannot be directly executed until all the libtool +# libraries that it depends on are installed. +# +# This wrapper script should never be moved out of the build directory. +# If it is, it will not operate correctly. + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed='${SED} -e 1s/^X//' +sed_quote_subst='$sed_quote_subst' + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi + +relink_command=\"$relink_command\" + +# This environment variable determines our operation mode. +if test \"\$libtool_install_magic\" = \"$magic\"; then + # install mode needs the following variable: + notinst_deplibs='$notinst_deplibs' +else + # When we are sourced in execute mode, \$file and \$echo are already set. + if test \"\$libtool_execute_magic\" != \"$magic\"; then + echo=\"$qecho\" + file=\"\$0\" + # Make sure echo works. + if test \"X\$1\" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift + elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then + # Yippee, \$echo works! + : + else + # Restart under the correct shell, and then maybe \$echo will work. + exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"} + fi + fi\ +" + $echo >> $output "\ + + # Find the directory that this script lives in. + thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\` + test \"x\$thisdir\" = \"x\$file\" && thisdir=. + + # Follow symbolic links until we get to the real thisdir. + file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\` + while test -n \"\$file\"; do + destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\` + + # If there was a directory component, then change thisdir. + if test \"x\$destdir\" != \"x\$file\"; then + case \"\$destdir\" in + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; + *) thisdir=\"\$thisdir/\$destdir\" ;; + esac + fi + + file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\` + file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\` + done + + # Try to get the absolute directory name. + absdir=\`cd \"\$thisdir\" && pwd\` + test -n \"\$absdir\" && thisdir=\"\$absdir\" +" + + if test "$fast_install" = yes; then + $echo >> $output "\ + program=lt-'$outputname'$exeext + progdir=\"\$thisdir/$objdir\" + + if test ! -f \"\$progdir/\$program\" || \\ + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ + test \"X\$file\" != \"X\$progdir/\$program\"; }; then + + file=\"\$\$-\$program\" + + if test ! -d \"\$progdir\"; then + $mkdir \"\$progdir\" + else + $rm \"\$progdir/\$file\" + fi" + + $echo >> $output "\ + + # relink executable if necessary + if test -n \"\$relink_command\"; then + if relink_command_output=\`eval \$relink_command 2>&1\`; then : + else + $echo \"\$relink_command_output\" >&2 + $rm \"\$progdir/\$file\" + exit $EXIT_FAILURE + fi + fi + + $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || + { $rm \"\$progdir/\$program\"; + $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; } + $rm \"\$progdir/\$file\" + fi" + else + $echo >> $output "\ + program='$outputname' + progdir=\"\$thisdir/$objdir\" +" + fi + + $echo >> $output "\ + + if test -f \"\$progdir/\$program\"; then" + + # Export our shlibpath_var if we have one. + if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then + $echo >> $output "\ + # Add our own library path to $shlibpath_var + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" + + # Some systems cannot cope with colon-terminated $shlibpath_var + # The second colon is a workaround for a bug in BeOS R4 sed + $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\` + + export $shlibpath_var +" + fi + + # fixup the dll searchpath if we need to. + if test -n "$dllsearchpath"; then + $echo >> $output "\ + # Add the dll search path components to the executable PATH + PATH=$dllsearchpath:\$PATH +" + fi + + $echo >> $output "\ + if test \"\$libtool_execute_magic\" != \"$magic\"; then + # Run the actual program with our arguments. +" + case $host in + # Backslashes separate directories on plain windows + *-*-mingw | *-*-os2*) + $echo >> $output "\ + exec \$progdir\\\\\$program \${1+\"\$@\"} +" + ;; + + *) + $echo >> $output "\ + exec \$progdir/\$program \${1+\"\$@\"} +" + ;; + esac + $echo >> $output "\ + \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\" + exit $EXIT_FAILURE + fi + else + # The program doesn't exist. + \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2 + \$echo \"This script is just a wrapper for \$program.\" 1>&2 + $echo \"See the $PACKAGE documentation for more information.\" 1>&2 + exit $EXIT_FAILURE + fi +fi\ +" + chmod +x $output + fi + exit $EXIT_SUCCESS + ;; + esac + + # See if we need to build an old-fashioned archive. + for oldlib in $oldlibs; do + + if test "$build_libtool_libs" = convenience; then + oldobjs="$libobjs_save" + addlibs="$convenience" + build_libtool_libs=no + else + if test "$build_libtool_libs" = module; then + oldobjs="$libobjs_save" + build_libtool_libs=no + else + oldobjs="$old_deplibs $non_pic_objects" + fi + addlibs="$old_convenience" + fi + + if test -n "$addlibs"; then + gentop="$output_objdir/${outputname}x" + $show "${rm}r $gentop" + $run ${rm}r "$gentop" + $show "$mkdir $gentop" + $run $mkdir "$gentop" + status=$? + if test "$status" -ne 0 && test ! -d "$gentop"; then + exit $status + fi + generated="$generated $gentop" + + # Add in members from convenience archives. + for xlib in $addlibs; do + # Extract the objects. + case $xlib in + [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;; + *) xabs=`pwd`"/$xlib" ;; + esac + xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'` + xdir="$gentop/$xlib" + + $show "${rm}r $xdir" + $run ${rm}r "$xdir" + $show "$mkdir $xdir" + $run $mkdir "$xdir" + status=$? + if test "$status" -ne 0 && test ! -d "$xdir"; then + exit $status + fi + # We will extract separately just the conflicting names and we will no + # longer touch any unique names. It is faster to leave these extract + # automatically by $AR in one run. + $show "(cd $xdir && $AR x $xabs)" + $run eval "(cd \$xdir && $AR x \$xabs)" || exit $? + if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; renaming object files" 1>&2 + $echo "$modename: warning: to ensure that they will not overwrite" 1>&2 + $AR t "$xabs" | sort | uniq -cd | while read -r count name + do + i=1 + while test "$i" -le "$count" + do + # Put our $i before any first dot (extension) + # Never overwrite any file + name_to="$name" + while test "X$name_to" = "X$name" || test -f "$xdir/$name_to" + do + name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"` + done + $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')" + $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $? + i=`expr $i + 1` + done + done + fi + + oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP` + done + fi + + # Do each command in the archive commands. + if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then + cmds=$old_archive_from_new_cmds + else + eval cmds=\"$old_archive_cmds\" + + if len=`expr "X$cmds" : ".*"` && + test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then + cmds=$old_archive_cmds + else + # the command line is too long to link in one step, link in parts + $echo "using piecewise archive linking..." + save_RANLIB=$RANLIB + RANLIB=: + objlist= + concat_cmds= + save_oldobjs=$oldobjs + # GNU ar 2.10+ was changed to match POSIX; thus no paths are + # encoded into archives. This makes 'ar r' malfunction in + # this piecewise linking case whenever conflicting object + # names appear in distinct ar calls; check, warn and compensate. + if (for obj in $save_oldobjs + do + $echo "X$obj" | $Xsed -e 's%^.*/%%' + done | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2 + $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2 + AR_FLAGS=cq + fi + # Is there a better way of finding the last object in the list? + for obj in $save_oldobjs + do + last_oldobj=$obj + done + for obj in $save_oldobjs + do + oldobjs="$objlist $obj" + objlist="$objlist $obj" + eval test_cmds=\"$old_archive_cmds\" + if len=`expr "X$test_cmds" : ".*"` && + test "$len" -le "$max_cmd_len"; then + : + else + # the above command should be used before it gets too long + oldobjs=$objlist + if test "$obj" = "$last_oldobj" ; then + RANLIB=$save_RANLIB + fi + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" + objlist= + fi + done + RANLIB=$save_RANLIB + oldobjs=$objlist + if test "X$oldobjs" = "X" ; then + eval cmds=\"\$concat_cmds\" + else + eval cmds=\"\$concat_cmds~\$old_archive_cmds\" + fi + fi + fi + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + eval cmd=\"$cmd\" + IFS="$save_ifs" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + done + + if test -n "$generated"; then + $show "${rm}r$generated" + $run ${rm}r$generated + fi + + # Now create the libtool archive. + case $output in + *.la) + old_library= + test "$build_old_libs" = yes && old_library="$libname.$libext" + $show "creating $output" + + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"` + relink_command="$var=\"$var_value\"; export $var; $relink_command" + fi + done + # Quote the link command for shipping. + relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" + relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"` + if test "$hardcode_automatic" = yes ; then + relink_command= + fi + + + # Only create the output if not a dry run. + if test -z "$run"; then + for installed in no yes; do + if test "$installed" = yes; then + if test -z "$install_libdir"; then + break + fi + output="$output_objdir/$outputname"i + # Replace all uninstalled libtool libraries with the installed ones + newdependency_libs= + for deplib in $dependency_libs; do + case $deplib in + *.la) + name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'` + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + if test -z "$libdir"; then + $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + newdependency_libs="$newdependency_libs $libdir/$name" + ;; + *) newdependency_libs="$newdependency_libs $deplib" ;; + esac + done + dependency_libs="$newdependency_libs" + newdlfiles= + for lib in $dlfiles; do + name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'` + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + if test -z "$libdir"; then + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + newdlfiles="$newdlfiles $libdir/$name" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'` + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + if test -z "$libdir"; then + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + newdlprefiles="$newdlprefiles $libdir/$name" + done + dlprefiles="$newdlprefiles" + else + newdlfiles= + for lib in $dlfiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + newdlfiles="$newdlfiles $abs" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + newdlprefiles="$newdlprefiles $abs" + done + dlprefiles="$newdlprefiles" + fi + $rm $output + # place dlname in correct position for cygwin + tdlname=$dlname + case $host,$output,$installed,$module,$dlname in + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;; + esac + $echo > $output "\ +# $outputname - a libtool library file +# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='$tdlname' + +# Names of this library. +library_names='$library_names' + +# The name of the static archive. +old_library='$old_library' + +# Libraries that this one depends upon. +dependency_libs='$dependency_libs' + +# Version information for $libname. +current=$current +age=$age +revision=$revision + +# Is this an already installed library? +installed=$installed + +# Should we warn about portability when linking against -modules? +shouldnotlink=$module + +# Files to dlopen/dlpreopen +dlopen='$dlfiles' +dlpreopen='$dlprefiles' + +# Directory that this library needs to be installed in: +libdir='$install_libdir'" + if test "$installed" = no && test "$need_relink" = yes; then + $echo >> $output "\ +relink_command=\"$relink_command\"" + fi + done + fi + + # Do a symbolic link so that the libtool archive can be found in + # LD_LIBRARY_PATH before the program is installed. + $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)" + $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $? + ;; + esac + exit $EXIT_SUCCESS + ;; + + # libtool install mode + install) + modename="$modename: install" + + # There may be an optional sh(1) argument at the beginning of + # install_prog (especially on Windows NT). + if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || + # Allow the use of GNU shtool's install command. + $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then + # Aesthetically quote it. + arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) + arg="\"$arg\"" + ;; + esac + install_prog="$arg " + arg="$1" + shift + else + install_prog= + arg="$nonopt" + fi + + # The real first argument should be the name of the installation program. + # Aesthetically quote it. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) + arg="\"$arg\"" + ;; + esac + install_prog="$install_prog$arg" + + # We need to accept at least all the BSD install flags. + dest= + files= + opts= + prev= + install_type= + isdir=no + stripme= + for arg + do + if test -n "$dest"; then + files="$files $dest" + dest="$arg" + continue + fi + + case $arg in + -d) isdir=yes ;; + -f) prev="-f" ;; + -g) prev="-g" ;; + -m) prev="-m" ;; + -o) prev="-o" ;; + -s) + stripme=" -s" + continue + ;; + -*) ;; + + *) + # If the previous option needed an argument, then skip it. + if test -n "$prev"; then + prev= + else + dest="$arg" + continue + fi + ;; + esac + + # Aesthetically quote the argument. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) + arg="\"$arg\"" + ;; + esac + install_prog="$install_prog $arg" + done + + if test -z "$install_prog"; then + $echo "$modename: you must specify an install program" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + if test -n "$prev"; then + $echo "$modename: the \`$prev' option requires an argument" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + if test -z "$files"; then + if test -z "$dest"; then + $echo "$modename: no file or destination specified" 1>&2 + else + $echo "$modename: you must specify a destination" 1>&2 + fi + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Strip any trailing slash from the destination. + dest=`$echo "X$dest" | $Xsed -e 's%/$%%'` + + # Check to see that the destination is a directory. + test -d "$dest" && isdir=yes + if test "$isdir" = yes; then + destdir="$dest" + destname= + else + destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'` + test "X$destdir" = "X$dest" && destdir=. + destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'` + + # Not a directory, so check to see that there is only one file specified. + set dummy $files + if test "$#" -gt 2; then + $echo "$modename: \`$dest' is not a directory" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + fi + case $destdir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + for file in $files; do + case $file in + *.lo) ;; + *) + $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + esac + done + ;; + esac + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + staticlibs= + future_libdirs= + current_libdirs= + for file in $files; do + + # Do each installation. + case $file in + *.$libext) + # Do the static libraries later. + staticlibs="$staticlibs $file" + ;; + + *.la) + # Check to see that this really is a libtool archive. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then : + else + $echo "$modename: \`$file' is not a valid libtool archive" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + library_names= + old_library= + relink_command= + # If there is no directory component, then add one. + case $file in + */* | *\\*) . $file ;; + *) . ./$file ;; + esac + + # Add the libdir to current_libdirs if it is the destination. + if test "X$destdir" = "X$libdir"; then + case "$current_libdirs " in + *" $libdir "*) ;; + *) current_libdirs="$current_libdirs $libdir" ;; + esac + else + # Note the libdir as a future libdir. + case "$future_libdirs " in + *" $libdir "*) ;; + *) future_libdirs="$future_libdirs $libdir" ;; + esac + fi + + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/ + test "X$dir" = "X$file/" && dir= + dir="$dir$objdir" + + if test -n "$relink_command"; then + # Determine the prefix the user has applied to our future dir. + inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"` + + # Don't allow the user to place us outside of our expected + # location b/c this prevents finding dependent libraries that + # are installed to the same prefix. + # At present, this check doesn't affect windows .dll's that + # are installed into $libdir/../bin (currently, that works fine) + # but it's something to keep an eye on. + if test "$inst_prefix_dir" = "$destdir"; then + $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2 + exit $EXIT_FAILURE + fi + + if test -n "$inst_prefix_dir"; then + # Stick the inst_prefix_dir data into the link command. + relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` + else + relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"` + fi + + $echo "$modename: warning: relinking \`$file'" 1>&2 + $show "$relink_command" + if $run eval "$relink_command"; then : + else + $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2 + exit $EXIT_FAILURE + fi + fi + + # See the names of the shared library. + set dummy $library_names + if test -n "$2"; then + realname="$2" + shift + shift + + srcname="$realname" + test -n "$relink_command" && srcname="$realname"T + + # Install the shared library and build the symlinks. + $show "$install_prog $dir/$srcname $destdir/$realname" + $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $? + if test -n "$stripme" && test -n "$striplib"; then + $show "$striplib $destdir/$realname" + $run eval "$striplib $destdir/$realname" || exit $? + fi + + if test "$#" -gt 0; then + # Delete the old symlinks, and create new ones. + for linkname + do + if test "$linkname" != "$realname"; then + $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)" + $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)" + fi + done + fi + + # Do each command in the postinstall commands. + lib="$destdir/$realname" + cmds=$postinstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + + # Install the pseudo-library for information purposes. + name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + instname="$dir/$name"i + $show "$install_prog $instname $destdir/$name" + $run eval "$install_prog $instname $destdir/$name" || exit $? + + # Maybe install the static library, too. + test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library" + ;; + + *.lo) + # Install (i.e. copy) a libtool object. + + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + destfile="$destdir/$destfile" + fi + + # Deduce the name of the destination old-style object file. + case $destfile in + *.lo) + staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"` + ;; + *.$objext) + staticdest="$destfile" + destfile= + ;; + *) + $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + # Install the libtool object if requested. + if test -n "$destfile"; then + $show "$install_prog $file $destfile" + $run eval "$install_prog $file $destfile" || exit $? + fi + + # Install the old object if enabled. + if test "$build_old_libs" = yes; then + # Deduce the name of the old-style object file. + staticobj=`$echo "X$file" | $Xsed -e "$lo2o"` + + $show "$install_prog $staticobj $staticdest" + $run eval "$install_prog \$staticobj \$staticdest" || exit $? + fi + exit $EXIT_SUCCESS + ;; + + *) + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + destfile="$destdir/$destfile" + fi + + # If the file is missing, and there is a .exe on the end, strip it + # because it is most likely a libtool script we actually want to + # install + stripped_ext="" + case $file in + *.exe) + if test ! -f "$file"; then + file=`$echo $file|${SED} 's,.exe$,,'` + stripped_ext=".exe" + fi + ;; + esac + + # Do a test to see if this is really a libtool program. + case $host in + *cygwin*|*mingw*) + wrapper=`$echo $file | ${SED} -e 's,.exe$,,'` + ;; + *) + wrapper=$file + ;; + esac + if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then + notinst_deplibs= + relink_command= + + # To insure that "foo" is sourced, and not "foo.exe", + # finese the cygwin/MSYS system by explicitly sourcing "foo." + # which disallows the automatic-append-.exe behavior. + case $build in + *cygwin* | *mingw*) wrapperdot=${wrapper}. ;; + *) wrapperdot=${wrapper} ;; + esac + # If there is no directory component, then add one. + case $file in + */* | *\\*) . ${wrapperdot} ;; + *) . ./${wrapperdot} ;; + esac + + # Check the variables that should have been set. + if test -z "$notinst_deplibs"; then + $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2 + exit $EXIT_FAILURE + fi + + finalize=yes + for lib in $notinst_deplibs; do + # Check to see that each library is installed. + libdir= + if test -f "$lib"; then + # If there is no directory component, then add one. + case $lib in + */* | *\\*) . $lib ;; + *) . ./$lib ;; + esac + fi + libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test + if test -n "$libdir" && test ! -f "$libfile"; then + $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2 + finalize=no + fi + done + + relink_command= + # To insure that "foo" is sourced, and not "foo.exe", + # finese the cygwin/MSYS system by explicitly sourcing "foo." + # which disallows the automatic-append-.exe behavior. + case $build in + *cygwin* | *mingw*) wrapperdot=${wrapper}. ;; + *) wrapperdot=${wrapper} ;; + esac + # If there is no directory component, then add one. + case $file in + */* | *\\*) . ${wrapperdot} ;; + *) . ./${wrapperdot} ;; + esac + + outputname= + if test "$fast_install" = no && test -n "$relink_command"; then + if test "$finalize" = yes && test -z "$run"; then + tmpdir="/tmp" + test -n "$TMPDIR" && tmpdir="$TMPDIR" + tmpdir="$tmpdir/libtool-$$" + save_umask=`umask` + umask 0077 + if $mkdir "$tmpdir"; then + umask $save_umask + else + umask $save_umask + $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2 + continue + fi + file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'` + outputname="$tmpdir/$file" + # Replace the output file specification. + relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'` + + $show "$relink_command" + if $run eval "$relink_command"; then : + else + $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2 + ${rm}r "$tmpdir" + continue + fi + file="$outputname" + else + $echo "$modename: warning: cannot relink \`$file'" 1>&2 + fi + else + # Install the binary that we compiled earlier. + file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"` + fi + fi + + # remove .exe since cygwin /usr/bin/install will append another + # one anyways + case $install_prog,$host in + */usr/bin/install*,*cygwin*) + case $file:$destfile in + *.exe:*.exe) + # this is ok + ;; + *.exe:*) + destfile=$destfile.exe + ;; + *:*.exe) + destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'` + ;; + esac + ;; + esac + $show "$install_prog$stripme $file $destfile" + $run eval "$install_prog\$stripme \$file \$destfile" || exit $? + test -n "$outputname" && ${rm}r "$tmpdir" + ;; + esac + done + + for file in $staticlibs; do + name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + + # Set up the ranlib parameters. + oldlib="$destdir/$name" + + $show "$install_prog $file $oldlib" + $run eval "$install_prog \$file \$oldlib" || exit $? + + if test -n "$stripme" && test -n "$old_striplib"; then + $show "$old_striplib $oldlib" + $run eval "$old_striplib $oldlib" || exit $? + fi + + # Do each command in the postinstall commands. + cmds=$old_postinstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + done + + if test -n "$future_libdirs"; then + $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2 + fi + + if test -n "$current_libdirs"; then + # Maybe just do a dry run. + test -n "$run" && current_libdirs=" -n$current_libdirs" + exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' + else + exit $EXIT_SUCCESS + fi + ;; + + # libtool finish mode + finish) + modename="$modename: finish" + libdirs="$nonopt" + admincmds= + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + for dir + do + libdirs="$libdirs $dir" + done + + for libdir in $libdirs; do + if test -n "$finish_cmds"; then + # Do each command in the finish commands. + cmds=$finish_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || admincmds="$admincmds + $cmd" + done + IFS="$save_ifs" + fi + if test -n "$finish_eval"; then + # Do the single finish_eval. + eval cmds=\"$finish_eval\" + $run eval "$cmds" || admincmds="$admincmds + $cmds" + fi + done + fi + + # Exit here if they wanted silent mode. + test "$show" = : && exit $EXIT_SUCCESS + + $echo "----------------------------------------------------------------------" + $echo "Libraries have been installed in:" + for libdir in $libdirs; do + $echo " $libdir" + done + $echo + $echo "If you ever happen to want to link against installed libraries" + $echo "in a given directory, LIBDIR, you must either use libtool, and" + $echo "specify the full pathname of the library, or use the \`-LLIBDIR'" + $echo "flag during linking and do at least one of the following:" + if test -n "$shlibpath_var"; then + $echo " - add LIBDIR to the \`$shlibpath_var' environment variable" + $echo " during execution" + fi + if test -n "$runpath_var"; then + $echo " - add LIBDIR to the \`$runpath_var' environment variable" + $echo " during linking" + fi + if test -n "$hardcode_libdir_flag_spec"; then + libdir=LIBDIR + eval flag=\"$hardcode_libdir_flag_spec\" + + $echo " - use the \`$flag' linker flag" + fi + if test -n "$admincmds"; then + $echo " - have your system administrator run these commands:$admincmds" + fi + if test -f /etc/ld.so.conf; then + $echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" + fi + $echo + $echo "See any operating system documentation about shared libraries for" + $echo "more information, such as the ld(1) and ld.so(8) manual pages." + $echo "----------------------------------------------------------------------" + exit $EXIT_SUCCESS + ;; + + # libtool execute mode + execute) + modename="$modename: execute" + + # The first argument is the command name. + cmd="$nonopt" + if test -z "$cmd"; then + $echo "$modename: you must specify a COMMAND" 1>&2 + $echo "$help" + exit $EXIT_FAILURE + fi + + # Handle -dlopen flags immediately. + for file in $execute_dlfiles; do + if test ! -f "$file"; then + $echo "$modename: \`$file' is not a file" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + dir= + case $file in + *.la) + # Check to see that this really is a libtool archive. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then : + else + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Read the libtool library. + dlname= + library_names= + + # If there is no directory component, then add one. + case $file in + */* | *\\*) . $file ;; + *) . ./$file ;; + esac + + # Skip this library if it cannot be dlopened. + if test -z "$dlname"; then + # Warn if it was a shared library. + test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'" + continue + fi + + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` + test "X$dir" = "X$file" && dir=. + + if test -f "$dir/$objdir/$dlname"; then + dir="$dir/$objdir" + else + $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2 + exit $EXIT_FAILURE + fi + ;; + + *.lo) + # Just add the directory containing the .lo file. + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` + test "X$dir" = "X$file" && dir=. + ;; + + *) + $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2 + continue + ;; + esac + + # Get the absolute pathname. + absdir=`cd "$dir" && pwd` + test -n "$absdir" && dir="$absdir" + + # Now add the directory to shlibpath_var. + if eval "test -z \"\$$shlibpath_var\""; then + eval "$shlibpath_var=\"\$dir\"" + else + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" + fi + done + + # This variable tells wrapper scripts just to set shlibpath_var + # rather than running their programs. + libtool_execute_magic="$magic" + + # Check if any of the arguments is a wrapper script. + args= + for file + do + case $file in + -*) ;; + *) + # Do a test to see if this is really a libtool program. + if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + # If there is no directory component, then add one. + case $file in + */* | *\\*) . $file ;; + *) . ./$file ;; + esac + + # Transform arg to wrapped name. + file="$progdir/$program" + fi + ;; + esac + # Quote arguments (to preserve shell metacharacters). + file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"` + args="$args \"$file\"" + done + + if test -z "$run"; then + if test -n "$shlibpath_var"; then + # Export the shlibpath_var. + eval "export $shlibpath_var" + fi + + # Restore saved environment variables + if test "${save_LC_ALL+set}" = set; then + LC_ALL="$save_LC_ALL"; export LC_ALL + fi + if test "${save_LANG+set}" = set; then + LANG="$save_LANG"; export LANG + fi + + # Now prepare to actually exec the command. + exec_cmd="\$cmd$args" + else + # Display what would be done. + if test -n "$shlibpath_var"; then + eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\"" + $echo "export $shlibpath_var" + fi + $echo "$cmd$args" + exit $EXIT_SUCCESS + fi + ;; + + # libtool clean and uninstall mode + clean | uninstall) + modename="$modename: $mode" + rm="$nonopt" + files= + rmforce= + exit_status=0 + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + for arg + do + case $arg in + -f) rm="$rm $arg"; rmforce=yes ;; + -*) rm="$rm $arg" ;; + *) files="$files $arg" ;; + esac + done + + if test -z "$rm"; then + $echo "$modename: you must specify an RM program" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + rmdirs= + + origobjdir="$objdir" + for file in $files; do + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` + if test "X$dir" = "X$file"; then + dir=. + objdir="$origobjdir" + else + objdir="$dir/$origobjdir" + fi + name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + test "$mode" = uninstall && objdir="$dir" + + # Remember objdir for removal later, being careful to avoid duplicates + if test "$mode" = clean; then + case " $rmdirs " in + *" $objdir "*) ;; + *) rmdirs="$rmdirs $objdir" ;; + esac + fi + + # Don't error if the file doesn't exist and rm -f was used. + if (test -L "$file") >/dev/null 2>&1 \ + || (test -h "$file") >/dev/null 2>&1 \ + || test -f "$file"; then + : + elif test -d "$file"; then + exit_status=1 + continue + elif test "$rmforce" = yes; then + continue + fi + + rmfiles="$file" + + case $name in + *.la) + # Possibly a libtool archive, so verify it. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + . $dir/$name + + # Delete the libtool libraries and symlinks. + for n in $library_names; do + rmfiles="$rmfiles $objdir/$n" + done + test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library" + test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i" + + if test "$mode" = uninstall; then + if test -n "$library_names"; then + # Do each command in the postuninstall commands. + cmds=$postuninstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" + if test "$?" -ne 0 && test "$rmforce" != yes; then + exit_status=1 + fi + done + IFS="$save_ifs" + fi + + if test -n "$old_library"; then + # Do each command in the old_postuninstall commands. + cmds=$old_postuninstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" + if test "$?" -ne 0 && test "$rmforce" != yes; then + exit_status=1 + fi + done + IFS="$save_ifs" + fi + # FIXME: should reinstall the best remaining shared library. + fi + fi + ;; + + *.lo) + # Possibly a libtool object, so verify it. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + + # Read the .lo file + . $dir/$name + + # Add PIC object to the list of files to remove. + if test -n "$pic_object" \ + && test "$pic_object" != none; then + rmfiles="$rmfiles $dir/$pic_object" + fi + + # Add non-PIC object to the list of files to remove. + if test -n "$non_pic_object" \ + && test "$non_pic_object" != none; then + rmfiles="$rmfiles $dir/$non_pic_object" + fi + fi + ;; + + *) + if test "$mode" = clean ; then + noexename=$name + case $file in + *.exe) + file=`$echo $file|${SED} 's,.exe$,,'` + noexename=`$echo $name|${SED} 's,.exe$,,'` + # $file with .exe has already been added to rmfiles, + # add $file without .exe + rmfiles="$rmfiles $file" + ;; + esac + # Do a test to see if this is a libtool program. + if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + relink_command= + . $dir/$noexename + + # note $name still contains .exe if it was in $file originally + # as does the version of $file that was added into $rmfiles + rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}" + if test "$fast_install" = yes && test -n "$relink_command"; then + rmfiles="$rmfiles $objdir/lt-$name" + fi + if test "X$noexename" != "X$name" ; then + rmfiles="$rmfiles $objdir/lt-${noexename}.c" + fi + fi + fi + ;; + esac + $show "$rm $rmfiles" + $run $rm $rmfiles || exit_status=1 + done + objdir="$origobjdir" + + # Try to remove the ${objdir}s in the directories where we deleted files + for dir in $rmdirs; do + if test -d "$dir"; then + $show "rmdir $dir" + $run rmdir $dir >/dev/null 2>&1 + fi + done + + exit $exit_status + ;; + + "") + $echo "$modename: you must specify a MODE" 1>&2 + $echo "$generic_help" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + if test -z "$exec_cmd"; then + $echo "$modename: invalid operation mode \`$mode'" 1>&2 + $echo "$generic_help" 1>&2 + exit $EXIT_FAILURE + fi +fi # test -z "$show_help" + +if test -n "$exec_cmd"; then + eval exec $exec_cmd + exit $EXIT_FAILURE +fi + +# We need to display help for each of the modes. +case $mode in +"") $echo \ +"Usage: $modename [OPTION]... [MODE-ARG]... + +Provide generalized library-building support services. + + --config show all configuration variables + --debug enable verbose shell tracing +-n, --dry-run display commands without modifying any files + --features display basic configuration information and exit + --finish same as \`--mode=finish' + --help display this help message and exit + --mode=MODE use operation mode MODE [default=inferred from MODE-ARGS] + --quiet same as \`--silent' + --silent don't print informational messages + --tag=TAG use configuration variables from tag TAG + --version print version information + +MODE must be one of the following: + + clean remove files from the build directory + compile compile a source file into a libtool object + execute automatically set library path, then run a program + finish complete the installation of libtool libraries + install install libraries or executables + link create a library or an executable + uninstall remove libraries from an installed directory + +MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for +a more detailed description of MODE. + +Report bugs to ." + exit $EXIT_SUCCESS + ;; + +clean) + $echo \ +"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE... + +Remove files from the build directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, object or program, all the files associated +with it are deleted. Otherwise, only FILE itself is deleted using RM." + ;; + +compile) + $echo \ +"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE + +Compile a source file into a libtool library object. + +This mode accepts the following additional options: + + -o OUTPUT-FILE set the output file name to OUTPUT-FILE + -prefer-pic try to building PIC objects only + -prefer-non-pic try to building non-PIC objects only + -static always build a \`.o' file suitable for static linking + +COMPILE-COMMAND is a command to be used in creating a \`standard' object file +from the given SOURCEFILE. + +The output file name is determined by removing the directory component from +SOURCEFILE, then substituting the C source code suffix \`.c' with the +library object suffix, \`.lo'." + ;; + +execute) + $echo \ +"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]... + +Automatically set library path, then run a program. + +This mode accepts the following additional options: + + -dlopen FILE add the directory containing FILE to the library path + +This mode sets the library path environment variable according to \`-dlopen' +flags. + +If any of the ARGS are libtool executable wrappers, then they are translated +into their corresponding uninstalled binary, and any of their required library +directories are added to the library path. + +Then, COMMAND is executed, with ARGS as arguments." + ;; + +finish) + $echo \ +"Usage: $modename [OPTION]... --mode=finish [LIBDIR]... + +Complete the installation of libtool libraries. + +Each LIBDIR is a directory that contains libtool libraries. + +The commands that this mode executes may require superuser privileges. Use +the \`--dry-run' option if you just want to see what would be executed." + ;; + +install) + $echo \ +"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND... + +Install executables or libraries. + +INSTALL-COMMAND is the installation command. The first component should be +either the \`install' or \`cp' program. + +The rest of the components are interpreted as arguments to that command (only +BSD-compatible install options are recognized)." + ;; + +link) + $echo \ +"Usage: $modename [OPTION]... --mode=link LINK-COMMAND... + +Link object files or libraries together to form another library, or to +create an executable program. + +LINK-COMMAND is a command using the C compiler that you would use to create +a program from several object files. + +The following components of LINK-COMMAND are treated specially: + + -all-static do not do any dynamic linking at all + -avoid-version do not add a version suffix if possible + -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) + -export-symbols SYMFILE + try to export only the symbols listed in SYMFILE + -export-symbols-regex REGEX + try to export only the symbols matching REGEX + -LLIBDIR search LIBDIR for required installed libraries + -lNAME OUTPUT-FILE requires the installed library libNAME + -module build a library that can dlopened + -no-fast-install disable the fast-install mode + -no-install link a not-installable executable + -no-undefined declare that a library does not refer to external symbols + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects + -objectlist FILE Use a list of object files found in FILE to specify objects + -precious-files-regex REGEX + don't remove output files matching REGEX + -release RELEASE specify package release information + -rpath LIBDIR the created library will eventually be installed in LIBDIR + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries + -static do not do any dynamic linking of libtool libraries + -version-info CURRENT[:REVISION[:AGE]] + specify library version info [each variable defaults to 0] + +All other options (arguments beginning with \`-') are ignored. + +Every other argument is treated as a filename. Files ending in \`.la' are +treated as uninstalled libtool libraries, other files are standard or library +object files. + +If the OUTPUT-FILE ends in \`.la', then a libtool library is created, +only library objects (\`.lo' files) may be specified, and \`-rpath' is +required, except when creating a convenience library. + +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created +using \`ar' and \`ranlib', or on Windows using \`lib'. + +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file +is created, otherwise an executable program is created." + ;; + +uninstall) + $echo \ +"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... + +Remove libraries from an installation directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, all the files associated with it are deleted. +Otherwise, only FILE itself is deleted using RM." + ;; + +*) + $echo "$modename: invalid operation mode \`$mode'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; +esac + +$echo +$echo "Try \`$modename --help' for more information about other modes." + +exit $EXIT_SUCCESS + +# The TAGs below are defined such that we never get into a situation +# in which we disable both kinds of libraries. Given conflicting +# choices, we go for a static library, that is the most portable, +# since we can't tell whether shared libraries were disabled because +# the user asked for that or because the platform doesn't support +# them. This is particularly important on AIX, because we don't +# support having both static and shared libraries enabled at the same +# time on that platform, so we default to a shared-only configuration. +# If a disable-shared tag is given, we'll fallback to a static-only +# configuration. But we'll never go from static-only to shared-only. + +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared +build_libtool_libs=no +build_old_libs=yes +# ### END LIBTOOL TAG CONFIG: disable-shared + +# ### BEGIN LIBTOOL TAG CONFIG: disable-static +build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac` +# ### END LIBTOOL TAG CONFIG: disable-static + +# Local Variables: +# mode:shell-script +# sh-indentation:2 +# End: +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# Libtool was configured on host ipf0v3330.pf.irt-aese.local: + +# Shell to use when invoking shell scripts. +SHELL="/bin/bash" + +# Whether or not to build shared libraries. +build_libtool_libs=yes + +# Whether or not to build static libraries. +build_old_libs=yes + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=no + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=no + +# Whether or not to optimize for fast installation. +fast_install=yes + +# The host system. +host_alias= +host=x86_64-unknown-linux-gnu + +# An echo program that does not interpret backslashes. +echo="echo" + +# The archiver. +AR="ar" +AR_FLAGS="cru" + +# A C compiler. +LTCC="gcc" + +# A language-specific compiler. +CC="g++" + +# Is the compiler the GNU C compiler? +with_gcc=yes + +# An ERE matcher. +EGREP="/bin/grep -E" + +# The linker used to build libraries. +LD="/usr/bin/ld -m elf_x86_64" + +# Whether we need hard or soft links. +LN_S="ln -s" + +# A BSD-compatible nm program. +NM="/usr/bin/nm -B" + +# A symbol stripping program +STRIP="strip" + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=file + +# Used on cygwin: DLL creation program. +DLLTOOL="dlltool" + +# Used on cygwin: object dumper. +OBJDUMP="objdump" + +# Used on cygwin: assembler. +AS="as" + +# The name of the directory that contains temporary libtool files. +objdir=.libs + +# How to create reloadable object files. +reload_flag=" -r" +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs" + +# How to pass a linker flag through the compiler. +wl="-Wl," + +# Object file suffix (normally "o"). +objext="o" + +# Old archive suffix (normally "a"). +libext="a" + +# Shared library suffix (normally ".so"). +shrext_cmds='.so' + +# Executable file suffix (normally ""). +exeext="" + +# Additional compiler flags for building library objects. +pic_flag=" -fPIC -DPIC" +pic_mode=default + +# What is the maximum length of a command? +max_cmd_len=32768 + +# Does compiler simultaneously support -c and -o options? +compiler_c_o="yes" + +# Must we lock files when doing compilation ? +need_locks="no" + +# Do we need the lib prefix for modules? +need_lib_prefix=no + +# Do we need a version for libraries? +need_version=no + +# Whether dlopen is supported. +dlopen_support=unknown + +# Whether dlopen of programs is supported. +dlopen_self=unknown + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=unknown + +# Compiler flag to prevent dynamic linking. +link_static_flag="-static" + +# Compiler flag to turn off builtin functions. +no_builtin_flag=" -fno-builtin" + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec="\${wl}--export-dynamic" + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive" + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec="" + +# Library versioning type. +version_type=linux + +# Format of library name prefix. +libname_spec="lib\$name" + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}" + +# The coded name of the library, if different from the real name. +soname_spec="\${libname}\${release}\${shared_ext}\$major" + +# Commands used to build and install an old-style archive. +RANLIB="ranlib" +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs\$old_deplibs~\$RANLIB \$oldlib" +old_postinstall_cmds="\$RANLIB \$oldlib~chmod 644 \$oldlib" +old_postuninstall_cmds="" + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds="" + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds="" + +# Commands used to build and install a shared archive. +archive_cmds="\$CC -shared -nostdlib \$predep_objects \$libobjs \$deplibs \$postdep_objects \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib" +archive_expsym_cmds="\$CC -shared -nostdlib \$predep_objects \$libobjs \$deplibs \$postdep_objects \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-retain-symbols-file \$wl\$export_symbols -o \$lib" +postinstall_cmds="" +postuninstall_cmds="" + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds="" +module_expsym_cmds="" + +# Commands to strip libraries. +old_striplib="strip --strip-debug" +striplib="strip --strip-unneeded" + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects="/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/5/crtbeginS.o" + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects="/usr/lib/gcc/x86_64-linux-gnu/5/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o" + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps="" + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps="-lstdc++ -lm -lgcc_s -lc -lgcc_s" + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path="-L/usr/lib/gcc/x86_64-linux-gnu/5 -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/5/../../.." + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method="pass_all" + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd="\$MAGIC_CMD" + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag="" + +# Flag that forces no undefined symbols. +no_undefined_flag="" + +# Commands used to finish a libtool library installation in a directory. +finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir" + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval="" + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\(\\)\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2\\3 \\3/p'" + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl="sed -n -e 's/^. .* \\(.*\\)\$/extern int \\1;/p'" + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/ {\\\"\\1\\\", (lt_ptr) 0},/p' -e 's/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/ {\"\\2\", (lt_ptr) \\&\\2},/p'" + +# This is the shared library runtime path variable. +runpath_var=LD_RUN_PATH + +# This is the shared library path variable. +shlibpath_var=LD_LIBRARY_PATH + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=no + +# How to hardcode a shared library path into an executable. +hardcode_action=immediate + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=yes + +# Flag to hardcode $libdir into a binary during linking. +# This must work even if $libdir does not exist. +hardcode_libdir_flag_spec="\${wl}--rpath \${wl}\$libdir" + +# If ld is used when linking, flag to hardcode $libdir into +# a binary during linking. This must work even if $libdir does +# not exist. +hardcode_libdir_flag_spec_ld="" + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator="" + +# Set to yes if using DIR/libNAME during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=no + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=no + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var= + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=no + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=unknown + +# Compile-time system search path for libraries +sys_lib_search_path_spec="/lib64 /usr/lib64 /usr/X11R6/lib64 /usr/local/lib64 include /etc/ld.so.conf.d/*.conf " + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /usr/X11R6/lib64 include /etc/ld.so.conf.d/*.conf " + +# Fix the shell variable $srcfile for the compiler. +fix_srcfile_path="" + +# Set to yes if exported symbols are required. +always_export_symbols=no + +# The commands to list exported symbols. +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols" + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds="" + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms="" + +# Symbols that must always be exported. +include_expsyms="" + +# ### END LIBTOOL TAG CONFIG: CXX + +# ### BEGIN LIBTOOL TAG CONFIG: F77 + +# Libtool was configured on host ipf0v3330.pf.irt-aese.local: + +# Shell to use when invoking shell scripts. +SHELL="/bin/bash" + +# Whether or not to build shared libraries. +build_libtool_libs=yes + +# Whether or not to build static libraries. +build_old_libs=yes + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=no + +# Whether or not to disallow shared libs when runtime libs are static +allow_libtool_libs_with_static_runtimes=no + +# Whether or not to optimize for fast installation. +fast_install=yes + +# The host system. +host_alias= +host=x86_64-unknown-linux-gnu + +# An echo program that does not interpret backslashes. +echo="echo" + +# The archiver. +AR="ar" +AR_FLAGS="cru" + +# A C compiler. +LTCC="gcc" + +# A language-specific compiler. +CC="f77" + +# Is the compiler the GNU C compiler? +with_gcc=yes + +# An ERE matcher. +EGREP="/bin/grep -E" + +# The linker used to build libraries. +LD="/usr/bin/ld -m elf_x86_64" + +# Whether we need hard or soft links. +LN_S="ln -s" + +# A BSD-compatible nm program. +NM="/usr/bin/nm -B" + +# A symbol stripping program +STRIP="strip" + +# Used to examine libraries when file_magic_cmd begins "file" +MAGIC_CMD=file + +# Used on cygwin: DLL creation program. +DLLTOOL="dlltool" + +# Used on cygwin: object dumper. +OBJDUMP="objdump" + +# Used on cygwin: assembler. +AS="as" + +# The name of the directory that contains temporary libtool files. +objdir=.libs + +# How to create reloadable object files. +reload_flag=" -r" +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs" + +# How to pass a linker flag through the compiler. +wl="-Wl," + +# Object file suffix (normally "o"). +objext="o" + +# Old archive suffix (normally "a"). +libext="a" + +# Shared library suffix (normally ".so"). +shrext_cmds='.so' + +# Executable file suffix (normally ""). +exeext="" + +# Additional compiler flags for building library objects. +pic_flag=" -fPIC" +pic_mode=default + +# What is the maximum length of a command? +max_cmd_len=32768 + +# Does compiler simultaneously support -c and -o options? +compiler_c_o="yes" + +# Must we lock files when doing compilation ? +need_locks="no" + +# Do we need the lib prefix for modules? +need_lib_prefix=no + +# Do we need a version for libraries? +need_version=no + +# Whether dlopen is supported. +dlopen_support=unknown + +# Whether dlopen of programs is supported. +dlopen_self=unknown + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=unknown + +# Compiler flag to prevent dynamic linking. +link_static_flag="-static" + +# Compiler flag to turn off builtin functions. +no_builtin_flag="" + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec="\${wl}--export-dynamic" + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive" + +# Compiler flag to generate thread-safe objects. +thread_safe_flag_spec="" + +# Library versioning type. +version_type=linux + +# Format of library name prefix. +libname_spec="lib\$name" + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME. +library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}" + +# The coded name of the library, if different from the real name. +soname_spec="\${libname}\${release}\${shared_ext}\$major" + +# Commands used to build and install an old-style archive. +RANLIB="ranlib" +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs\$old_deplibs~\$RANLIB \$oldlib" +old_postinstall_cmds="\$RANLIB \$oldlib~chmod 644 \$oldlib" +old_postuninstall_cmds="" + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds="" + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds="" + +# Commands used to build and install a shared archive. +archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib" +archive_expsym_cmds="\$echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~ +cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~ +\$echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~ + \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib" +postinstall_cmds="" +postuninstall_cmds="" + +# Commands used to build a loadable module (assumed same as above if empty) +module_cmds="" +module_expsym_cmds="" + +# Commands to strip libraries. +old_striplib="strip --strip-debug" +striplib="strip --strip-unneeded" + +# Dependencies to place before the objects being linked to create a +# shared library. +predep_objects="" + +# Dependencies to place after the objects being linked to create a +# shared library. +postdep_objects="" + +# Dependencies to place before the objects being linked to create a +# shared library. +predeps="" + +# Dependencies to place after the objects being linked to create a +# shared library. +postdeps="" + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path="" + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method="pass_all" + +# Command to use when deplibs_check_method == file_magic. +file_magic_cmd="\$MAGIC_CMD" + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag="" + +# Flag that forces no undefined symbols. +no_undefined_flag="" + +# Commands used to finish a libtool library installation in a directory. +finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir" + +# Same as above, but a single script fragment to be evaled but not shown. +finish_eval="" + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\(\\)\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2\\3 \\3/p'" + +# Transform the output of nm in a proper C declaration +global_symbol_to_cdecl="sed -n -e 's/^. .* \\(.*\\)\$/extern int \\1;/p'" + +# Transform the output of nm in a C name address pair +global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/ {\\\"\\1\\\", (lt_ptr) 0},/p' -e 's/^[BCDEGRST] \\([^ ]*\\) \\([^ ]*\\)\$/ {\"\\2\", (lt_ptr) \\&\\2},/p'" + +# This is the shared library runtime path variable. +runpath_var=LD_RUN_PATH + +# This is the shared library path variable. +shlibpath_var=LD_LIBRARY_PATH + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=no + +# How to hardcode a shared library path into an executable. +hardcode_action=immediate + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=yes + +# Flag to hardcode $libdir into a binary during linking. +# This must work even if $libdir does not exist. +hardcode_libdir_flag_spec="\${wl}--rpath \${wl}\$libdir" + +# If ld is used when linking, flag to hardcode $libdir into +# a binary during linking. This must work even if $libdir does +# not exist. +hardcode_libdir_flag_spec_ld="" + +# Whether we need a single -rpath flag with a separated argument. +hardcode_libdir_separator="" + +# Set to yes if using DIR/libNAME during linking hardcodes DIR into the +# resulting binary. +hardcode_direct=no + +# Set to yes if using the -LDIR flag during linking hardcodes DIR into the +# resulting binary. +hardcode_minus_L=no + +# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into +# the resulting binary. +hardcode_shlibpath_var=unsupported + +# Set to yes if building a shared library automatically hardcodes DIR into the library +# and all subsequent libraries and executables linked against it. +hardcode_automatic=no + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at relink time. +variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=unknown + +# Compile-time system search path for libraries +sys_lib_search_path_spec="/lib64 /usr/lib64 /usr/X11R6/lib64 /usr/local/lib64 include /etc/ld.so.conf.d/*.conf " + +# Run-time system search path for libraries +sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /usr/X11R6/lib64 include /etc/ld.so.conf.d/*.conf " + +# Fix the shell variable $srcfile for the compiler. +fix_srcfile_path="" + +# Set to yes if exported symbols are required. +always_export_symbols=no + +# The commands to list exported symbols. +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols" + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds="" + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms="_GLOBAL_OFFSET_TABLE_" + +# Symbols that must always be exported. +include_expsyms="" + +# ### END LIBTOOL TAG CONFIG: F77 + diff --git a/sdk/buddy-2.4/m4/debug.m4 b/sdk/buddy-2.4/m4/debug.m4 new file mode 100644 index 0000000..afc0fb2 --- /dev/null +++ b/sdk/buddy-2.4/m4/debug.m4 @@ -0,0 +1,25 @@ +AC_DEFUN([buddy_DEBUG_FLAGS], +[AC_ARG_ENABLE([swap-count], + [AC_HELP_STRING([--enable-swap-count], + [Count number of fundamental variable swaps (for debugging)])]) +case $enable_swap_count in + yes) + AC_DEFINE([SWAPCOUNT], 1, + [Define to 1 to count number of fundamental variable swaps + (for debugging).]) + ;; +esac + +AC_ARG_ENABLE([cache-stats], + [AC_HELP_STRING([--enable-cache-stats], + [Gather statistical information about operator and unique node caching (for debugging)])]) +case $enable_cache_stats in + yes) + AC_DEFINE([CACHESTATS], 1, + [Defube to 1 to gather statistical information about operator and unique node caching (for debugging).]) + ;; +esac +]) + + + \ No newline at end of file diff --git a/sdk/buddy-2.4/src/Makefile.am b/sdk/buddy-2.4/src/Makefile.am new file mode 100644 index 0000000..210dc9f --- /dev/null +++ b/sdk/buddy-2.4/src/Makefile.am @@ -0,0 +1,31 @@ +AM_CPPFLAGS = -I$(top_builddir) + +include_HEADERS = bdd.h fdd.h bvec.h + +lib_LTLIBRARIES = libbdd.la +libbdd_la_SOURCES = \ + bddio.c \ + bddop.c \ + bddtree.h \ + bvec.c \ + cache.c \ + cache.h \ + cppext.cxx \ + fdd.c \ + imatrix.c \ + imatrix.h \ + kernel.c \ + kernel.h \ + pairs.c \ + prime.c \ + prime.h \ + reorder.c \ + tree.c + +# See the `Updating version info' node of the Libtool manual before +# changing this. +libbdd_la_LDFLAGS = -version-info 0:0:0 + +check_PROGRAMS = bddtest +bddtest_SOURCES = bddtest.cxx +bddtest_LDADD = ./libbdd.la diff --git a/sdk/buddy-2.4/src/Makefile.in b/sdk/buddy-2.4/src/Makefile.in new file mode 100644 index 0000000..3618d1c --- /dev/null +++ b/sdk/buddy-2.4/src/Makefile.in @@ -0,0 +1,566 @@ +# Makefile.in generated by automake 1.8.5 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +SOURCES = $(libbdd_la_SOURCES) $(bddtest_SOURCES) + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +top_builddir = .. +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +INSTALL = @INSTALL@ +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +host_triplet = @host@ +check_PROGRAMS = bddtest$(EXEEXT) +subdir = src +DIST_COMMON = $(include_HEADERS) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/debug.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(mkdir_p) +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" +libLTLIBRARIES_INSTALL = $(INSTALL) +LTLIBRARIES = $(lib_LTLIBRARIES) +libbdd_la_LIBADD = +am_libbdd_la_OBJECTS = bddio.lo bddop.lo bvec.lo cache.lo cppext.lo \ + fdd.lo imatrix.lo kernel.lo pairs.lo prime.lo reorder.lo \ + tree.lo +libbdd_la_OBJECTS = $(am_libbdd_la_OBJECTS) +am_bddtest_OBJECTS = bddtest.$(OBJEXT) +bddtest_OBJECTS = $(am_bddtest_OBJECTS) +bddtest_DEPENDENCIES = ./libbdd.la +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/tools/depcomp +am__depfiles_maybe = depfiles +@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/bddio.Plo ./$(DEPDIR)/bddop.Plo \ +@AMDEP_TRUE@ ./$(DEPDIR)/bddtest.Po ./$(DEPDIR)/bvec.Plo \ +@AMDEP_TRUE@ ./$(DEPDIR)/cache.Plo ./$(DEPDIR)/cppext.Plo \ +@AMDEP_TRUE@ ./$(DEPDIR)/fdd.Plo ./$(DEPDIR)/imatrix.Plo \ +@AMDEP_TRUE@ ./$(DEPDIR)/kernel.Plo ./$(DEPDIR)/pairs.Plo \ +@AMDEP_TRUE@ ./$(DEPDIR)/prime.Plo ./$(DEPDIR)/reorder.Plo \ +@AMDEP_TRUE@ ./$(DEPDIR)/tree.Plo +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +SOURCES = $(libbdd_la_SOURCES) $(bddtest_SOURCES) +DIST_SOURCES = $(libbdd_la_SOURCES) $(bddtest_SOURCES) +includeHEADERS_INSTALL = $(INSTALL_HEADER) +HEADERS = $(include_HEADERS) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMDEP_FALSE = @AMDEP_FALSE@ +AMDEP_TRUE = @AMDEP_TRUE@ +AMTAR = @AMTAR@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +ECHO = @ECHO@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +F77 = @F77@ +FFLAGS = @FFLAGS@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LDFLAGS = @LDFLAGS@ +LEX = @LEX@ +LEXLIB = @LEXLIB@ +LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +OBJEXT = @OBJEXT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +RANLIB = @RANLIB@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +YACC = @YACC@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_F77 = @ac_ct_F77@ +ac_ct_RANLIB = @ac_ct_RANLIB@ +ac_ct_STRIP = @ac_ct_STRIP@ +am__fastdepCC_FALSE = @am__fastdepCC_FALSE@ +am__fastdepCC_TRUE = @am__fastdepCC_TRUE@ +am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@ +am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +datadir = @datadir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +AM_CPPFLAGS = -I$(top_builddir) +include_HEADERS = bdd.h fdd.h bvec.h +lib_LTLIBRARIES = libbdd.la +libbdd_la_SOURCES = \ + bddio.c \ + bddop.c \ + bddtree.h \ + bvec.c \ + cache.c \ + cache.h \ + cppext.cxx \ + fdd.c \ + imatrix.c \ + imatrix.h \ + kernel.c \ + kernel.h \ + pairs.c \ + prime.c \ + prime.h \ + reorder.c \ + tree.c + + +# See the `Updating version info' node of the Libtool manual before +# changing this. +libbdd_la_LDFLAGS = -version-info 0:0:0 +bddtest_SOURCES = bddtest.cxx +bddtest_LDADD = ./libbdd.la +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .cxx .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + test -z "$(libdir)" || $(mkdir_p) "$(DESTDIR)$(libdir)" + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + if test -f $$p; then \ + f="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " $(LIBTOOL) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(libdir)/$$f"; \ + else :; fi; \ + done + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + p="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$p'"; \ + $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$p"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done +libbdd.la: $(libbdd_la_OBJECTS) $(libbdd_la_DEPENDENCIES) + $(CXXLINK) -rpath $(libdir) $(libbdd_la_LDFLAGS) $(libbdd_la_OBJECTS) $(libbdd_la_LIBADD) $(LIBS) + +clean-checkPROGRAMS: + @list='$(check_PROGRAMS)'; for p in $$list; do \ + f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f $$p $$f"; \ + rm -f $$p $$f ; \ + done +bddtest$(EXEEXT): $(bddtest_OBJECTS) $(bddtest_DEPENDENCIES) + @rm -f bddtest$(EXEEXT) + $(CXXLINK) $(bddtest_LDFLAGS) $(bddtest_OBJECTS) $(bddtest_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bddio.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bddop.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bddtest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bvec.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cache.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cppext.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fdd.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/imatrix.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/kernel.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pairs.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prime.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reorder.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tree.Plo@am__quote@ + +.c.o: +@am__fastdepCC_TRUE@ if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \ +@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c $< + +.c.obj: +@am__fastdepCC_TRUE@ if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \ +@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \ +@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $< + +.cxx.o: +@am__fastdepCXX_TRUE@ if $(CXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cxx.obj: +@am__fastdepCXX_TRUE@ if $(CXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cxx.lo: +@am__fastdepCXX_TRUE@ if $(LTCXXCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \ +@am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool +uninstall-info-am: +install-includeHEADERS: $(include_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(includedir)" || $(mkdir_p) "$(DESTDIR)$(includedir)" + @list='$(include_HEADERS)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + f="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " $(includeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(includedir)/$$f'"; \ + $(includeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(includedir)/$$f"; \ + done + +uninstall-includeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(include_HEADERS)'; for p in $$list; do \ + f="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " rm -f '$(DESTDIR)$(includedir)/$$f'"; \ + rm -f "$(DESTDIR)$(includedir)/$$f"; \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \ + list='$(DISTFILES)'; for file in $$list; do \ + case $$file in \ + $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \ + $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \ + esac; \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test "$$dir" != "$$file" && test "$$dir" != "."; then \ + dir="/$$dir"; \ + $(mkdir_p) "$(distdir)$$dir"; \ + else \ + dir=''; \ + fi; \ + if test -d $$d/$$file; then \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS) +check: check-am +all-am: Makefile $(LTLIBRARIES) $(HEADERS) +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)"; do \ + test -z "$$dir" || $(mkdir_p) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-checkPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-libtool distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +info: info-am + +info-am: + +install-data-am: install-includeHEADERS + +install-exec-am: install-libLTLIBRARIES + +install-info: install-info-am + +install-man: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-includeHEADERS uninstall-info-am \ + uninstall-libLTLIBRARIES + +.PHONY: CTAGS GTAGS all all-am check check-am clean \ + clean-checkPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool ctags distclean distclean-compile \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-exec install-exec-am \ + install-includeHEADERS install-info install-info-am \ + install-libLTLIBRARIES install-man install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags uninstall uninstall-am uninstall-includeHEADERS \ + uninstall-info-am uninstall-libLTLIBRARIES + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/sdk/buddy-2.4/src/bdd.h b/sdk/buddy-2.4/src/bdd.h new file mode 100644 index 0000000..6f55d7a --- /dev/null +++ b/sdk/buddy-2.4/src/bdd.h @@ -0,0 +1,838 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bdd.h,v 1.1.1.1 2004/06/25 13:22:09 haimcohen Exp $ + FILE: bdd.h + DESCR: C,C++ User interface for the BDD package + AUTH: Jorn Lind + DATE: (C) feb 1997 +*************************************************************************/ + +#ifndef _BDD_H +#define _BDD_H + + /* Allow this headerfile to define C++ constructs if requested */ +#ifdef __cplusplus +#define CPLUSPLUS +#endif + +#include + +/*=== Defined operators for apply calls ================================*/ + +#define bddop_and 0 +#define bddop_xor 1 +#define bddop_or 2 +#define bddop_nand 3 +#define bddop_nor 4 +#define bddop_imp 5 +#define bddop_biimp 6 +#define bddop_diff 7 +#define bddop_less 8 +#define bddop_invimp 9 + + /* Should *not* be used in bdd_apply calls !!! */ +#define bddop_not 10 +#define bddop_simplify 11 + + +/*=== User BDD types ===================================================*/ + +typedef int BDD; + +#ifndef CPLUSPLUS +typedef BDD bdd; +#endif /* CPLUSPLUS */ + + +typedef struct s_bddPair +{ + BDD *result; + int last; + int id; + struct s_bddPair *next; +} bddPair; + + +/*=== Status information ===============================================*/ + +/* +NAME {* bddStat *} +SECTION {* kernel *} +SHORT {* Status information about the bdd package *} +PROTO {* typedef struct s_bddStat +{ + long int produced; + int nodenum; + int maxnodenum; + int freenodes; + int minfreenodes; + int varnum; + int cachesize; + int gbcnum; +} bddStat; *} +DESCR {* The fields are \\[\baselineskip] \begin{tabular}{lp{10cm}} + {\tt produced} & total number of new nodes ever produced \\ + {\tt nodenum} & currently allocated number of bdd nodes \\ + {\tt maxnodenum} & user defined maximum number of bdd nodes \\ + {\tt freenodes} & number of currently free nodes \\ + {\tt minfreenodes} & minimum number of nodes that should be left after a + garbage collection. \\ + {\tt varnum} & number of defined bdd variables \\ + {\tt cachesize} & number of entries in the internal caches \\ + {\tt gbcnum} & number of garbage collections done until now + \end{tabular} *} +ALSO {* bdd\_stats *} +*/ +typedef struct s_bddStat +{ + long int produced; + int nodenum; + int maxnodenum; + int freenodes; + int minfreenodes; + int varnum; + int cachesize; + int gbcnum; +} bddStat; + + +/* +NAME {* bddGbcStat *} +SECTION {* kernel *} +SHORT {* Status information about garbage collections *} +PROTO {* typedef struct s_bddGbcStat +{ + int nodes; + int freenodes; + long time; + long sumtime; + int num; +} bddGbcStat; *} +DESCR {* The fields are \\[\baselineskip] \begin{tabular}{ll} + {\tt nodes} & Total number of allocated nodes in the nodetable \\ + {\tt freenodes} & Number of free nodes in the nodetable \\ + {\tt time} & Time used for garbage collection this time \\ + {\tt sumtime} & Total time used for garbage collection \\ + {\tt num} & number of garbage collections done until now + \end{tabular} *} +ALSO {* bdd\_gbc\_hook *} +*/ +typedef struct s_bddGbcStat +{ + int nodes; + int freenodes; + long time; + long sumtime; + int num; +} bddGbcStat; + + +/* +NAME {* bddCacheStat *} +SECTION {* kernel *} +SHORT {* Status information about cache usage *} +PROTO {* typedef struct s_bddCacheStat +{ + long unsigned int uniqueAccess; + long unsigned int uniqueChain; + long unsigned int uniqueHit; + long unsigned int uniqueMiss; + long unsigned int opHit; + long unsigned int opMiss; + long unsigned int swapCount; +} bddCacheStat; *} +DESCR {* The fields are \\[\baselineskip] \begin{tabular}{ll} + {\bf Name} & {\bf Number of } \\ + uniqueAccess & accesses to the unique node table \\ + uniqueChain & iterations through the cache chains in the unique node table\\ + uniqueHit & entries actually found in the the unique node table \\ + uniqueMiss & entries not found in the the unique node table \\ + opHit & entries found in the operator caches \\ + opMiss & entries not found in the operator caches \\ + swapCount & number of variable swaps in reordering \\ +\end{tabular} *} +ALSO {* bdd\_cachestats *} +*/ +typedef struct s_bddCacheStat +{ + long unsigned int uniqueAccess; + long unsigned int uniqueChain; + long unsigned int uniqueHit; + long unsigned int uniqueMiss; + long unsigned int opHit; + long unsigned int opMiss; + long unsigned int swapCount; +} bddCacheStat; + +/*=== BDD interface prototypes =========================================*/ + +/* +NAME {* bdd\_relprod *} +SECTION {* operator *} +SHORT {* relational product *} +PROTO {* #define bdd_relprod(a,b,var) bdd_appex(a,b,bddop_and,var) *} +DESCR {* Calculates the relational product of {\tt a} and {\tt b} as + {\tt a AND b} with the variables in {\tt var} quantified out + afterwards. *} +RETURN {* The relational product or {\tt bddfalse} on errors. *} +ALSO {* bdd\_appex *} +*/ +#define bdd_relprod(a,b,var) bdd_appex((a),(b),bddop_and,(var)) + + + /* In file "kernel.c" */ + +#ifdef CPLUSPLUS +extern "C" { +#endif + +typedef void (*bddinthandler)(int); +typedef void (*bddgbchandler)(int,bddGbcStat*); +typedef void (*bdd2inthandler)(int,int); +typedef int (*bddsizehandler)(void); +typedef void (*bddfilehandler)(FILE *, int); +typedef void (*bddallsathandler)(char*, int); + +extern bddinthandler bdd_error_hook(bddinthandler); +extern bddgbchandler bdd_gbc_hook(bddgbchandler); +extern bdd2inthandler bdd_resize_hook(bdd2inthandler); +extern bddinthandler bdd_reorder_hook(bddinthandler); +extern bddfilehandler bdd_file_hook(bddfilehandler); + +extern int bdd_init(int, int); +extern void bdd_done(void); +extern int bdd_setvarnum(int); +extern int bdd_extvarnum(int); +extern int bdd_isrunning(void); +extern int bdd_setmaxnodenum(int); +extern int bdd_setmaxincrease(int); +extern int bdd_setminfreenodes(int); +extern int bdd_getnodenum(void); +extern int bdd_getallocnum(void); +extern char* bdd_versionstr(void); +extern int bdd_versionnum(void); +extern void bdd_stats(bddStat *); +extern void bdd_cachestats(bddCacheStat *); +extern void bdd_fprintstat(FILE *); +extern void bdd_printstat(void); +extern void bdd_default_gbchandler(int, bddGbcStat *); +extern void bdd_default_errhandler(int); +extern const char *bdd_errstring(int); +extern void bdd_clear_error(void); +#ifndef CPLUSPLUS +extern BDD bdd_true(void); +extern BDD bdd_false(void); +#endif +extern int bdd_varnum(void); +extern BDD bdd_ithvar(int); +extern BDD bdd_nithvar(int); +extern int bdd_var(BDD); +extern BDD bdd_low(BDD); +extern BDD bdd_high(BDD); +extern int bdd_varlevel(int); +extern BDD bdd_addref(BDD); +extern BDD bdd_delref(BDD); +extern void bdd_gbc(void); +extern int bdd_scanset(BDD, int**, int*); +extern BDD bdd_makeset(int *, int); +extern bddPair* bdd_newpair(void); +extern int bdd_setpair(bddPair*, int, int); +extern int bdd_setpairs(bddPair*, int*, int*, int); +extern int bdd_setbddpair(bddPair*, int, BDD); +extern int bdd_setbddpairs(bddPair*, int*, BDD*, int); +extern void bdd_resetpair(bddPair *); +extern void bdd_freepair(bddPair*); + + /* In bddop.c */ + +extern int bdd_setcacheratio(int); +extern BDD bdd_buildcube(int, int, BDD *); +extern BDD bdd_ibuildcube(int, int, int *); +extern BDD bdd_not(BDD); +extern BDD bdd_apply(BDD, BDD, int); +extern BDD bdd_and(BDD, BDD); +extern BDD bdd_or(BDD, BDD); +extern BDD bdd_xor(BDD, BDD); +extern BDD bdd_imp(BDD, BDD); +extern BDD bdd_biimp(BDD, BDD); +extern BDD bdd_ite(BDD, BDD, BDD); +extern BDD bdd_restrict(BDD, BDD); +extern BDD bdd_constrain(BDD, BDD); +extern BDD bdd_replace(BDD, bddPair*); +extern BDD bdd_compose(BDD, BDD, BDD); +extern BDD bdd_veccompose(BDD, bddPair*); +extern BDD bdd_simplify(BDD, BDD); +extern BDD bdd_exist(BDD, BDD); +extern BDD bdd_project(BDD, BDD); +extern BDD bdd_forall(BDD, BDD); +extern BDD bdd_unique(BDD, BDD); +extern BDD bdd_appex(BDD, BDD, int, BDD); +extern BDD bdd_appall(BDD, BDD, int, BDD); +extern BDD bdd_appuni(BDD, BDD, int, BDD); +extern BDD bdd_support(BDD); +extern BDD bdd_satone(BDD); +extern BDD bdd_satoneset(BDD, BDD, BDD); +extern BDD bdd_fullsatone(BDD); +extern void bdd_allsat(BDD r, bddallsathandler handler); +extern double bdd_satcount(BDD); +extern double bdd_satcountset(BDD, BDD); +extern double bdd_satcountln(BDD); +extern double bdd_satcountlnset(BDD, BDD); +extern int bdd_nodecount(BDD); +extern int bdd_anodecount(BDD *, int); +extern int* bdd_varprofile(BDD); +extern double bdd_pathcount(BDD); + + +/* In file "bddio.c" */ + +extern void bdd_printall(void); +extern void bdd_fprintall(FILE *); +extern void bdd_fprinttable(FILE *, BDD); +extern void bdd_printtable(BDD); +extern void bdd_fprintset(FILE *, BDD); +extern void bdd_printset(BDD); +extern int bdd_fnprintdot(char *, BDD); +extern void bdd_fprintdot(FILE *, BDD); +extern void bdd_printdot(BDD); +extern int bdd_fnsave(char *, BDD); +extern int bdd_save(FILE *, BDD); +extern int bdd_fnload(char *, BDD *); +extern int bdd_load(FILE *ifile, BDD *); + +/* In file reorder.c */ + +extern int bdd_swapvar(int v1, int v2); +extern void bdd_default_reohandler(int); +extern void bdd_reorder(int); +extern int bdd_reorder_gain(void); +extern bddsizehandler bdd_reorder_probe(bddsizehandler); +extern void bdd_clrvarblocks(void); +extern int bdd_addvarblock(BDD, int); +extern int bdd_intaddvarblock(int, int, int); +extern void bdd_varblockall(void); +extern bddfilehandler bdd_blockfile_hook(bddfilehandler); +extern int bdd_autoreorder(int); +extern int bdd_autoreorder_times(int, int); +extern int bdd_var2level(int); +extern int bdd_level2var(int); +extern int bdd_getreorder_times(void); +extern int bdd_getreorder_method(void); +extern void bdd_enable_reorder(void); +extern void bdd_disable_reorder(void); +extern int bdd_reorder_verbose(int); +extern void bdd_setvarorder(int *); +extern void bdd_printorder(void); +extern void bdd_fprintorder(FILE *); + +#ifdef CPLUSPLUS +} +#endif + + +/*=== BDD constants ====================================================*/ + +#ifndef CPLUSPLUS + +extern const BDD bddfalse; +extern const BDD bddtrue; + +#endif /* CPLUSPLUS */ + + +/*=== Reordering algorithms ============================================*/ + +#define BDD_REORDER_NONE 0 +#define BDD_REORDER_WIN2 1 +#define BDD_REORDER_WIN2ITE 2 +#define BDD_REORDER_SIFT 3 +#define BDD_REORDER_SIFTITE 4 +#define BDD_REORDER_WIN3 5 +#define BDD_REORDER_WIN3ITE 6 +#define BDD_REORDER_RANDOM 7 + +#define BDD_REORDER_FREE 0 +#define BDD_REORDER_FIXED 1 + + +/*=== Error codes ======================================================*/ + +#define BDD_MEMORY (-1) /* Out of memory */ +#define BDD_VAR (-2) /* Unknown variable */ +#define BDD_RANGE (-3) /* Variable value out of range (not in domain) */ +#define BDD_DEREF (-4) /* Removing external reference to unknown node */ +#define BDD_RUNNING (-5) /* Called bdd_init() twice whithout bdd_done() */ +#define BDD_FILE (-6) /* Some file operation failed */ +#define BDD_FORMAT (-7) /* Incorrect file format */ +#define BDD_ORDER (-8) /* Vars. not in order for vector based functions */ +#define BDD_BREAK (-9) /* User called break */ +#define BDD_VARNUM (-10) /* Different number of vars. for vector pair */ +#define BDD_NODES (-11) /* Tried to set max. number of nodes to be fewer */ + /* than there already has been allocated */ +#define BDD_OP (-12) /* Unknown operator */ +#define BDD_VARSET (-13) /* Illegal variable set */ +#define BDD_VARBLK (-14) /* Bad variable block operation */ +#define BDD_DECVNUM (-15) /* Trying to decrease the number of variables */ +#define BDD_REPLACE (-16) /* Replacing to already existing variables */ +#define BDD_NODENUM (-17) /* Number of nodes reached user defined maximum */ +#define BDD_ILLBDD (-18) /* Illegal bdd argument */ +#define BDD_SIZE (-19) /* Illegal size argument */ + +#define BVEC_SIZE (-20) /* Mismatch in bitvector size */ +#define BVEC_SHIFT (-21) /* Illegal shift-left/right parameter */ +#define BVEC_DIVZERO (-22) /* Division by zero */ + +#define BDD_ERRNUM 24 + +/************************************************************************* + If this file is included from a C++ compiler then the following + classes, wrappers and hacks are supplied. +*************************************************************************/ +#ifdef CPLUSPLUS +#include + +/*=== User BDD class ===================================================*/ + +class bvec; + +class bdd +{ + public: + + bdd(void) { root=0; } + bdd(const bdd &r) { bdd_addref(root=r.root); } + ~bdd(void) { bdd_delref(root); } + + int id(void) const; + + bdd operator=(const bdd &r); + + bdd operator&(const bdd &r) const; + bdd operator&=(const bdd &r); + bdd operator^(const bdd &r) const; + bdd operator^=(const bdd &r); + bdd operator|(const bdd &r) const; + bdd operator|=(const bdd &r); + bdd operator!(void) const; + bdd operator>>(const bdd &r) const; + bdd operator>>=(const bdd &r); + bdd operator-(const bdd &r) const; + bdd operator-=(const bdd &r); + bdd operator>(const bdd &r) const; + bdd operator<(const bdd &r) const; + bdd operator<<(const bdd &r) const; + bdd operator<<=(const bdd &r); + int operator==(const bdd &r) const; + int operator!=(const bdd &r) const; + +private: + BDD root; + + bdd(BDD r) { bdd_addref(root=r); } + bdd operator=(BDD r); + + friend int bdd_init(int, int); + friend int bdd_setvarnum(int); + friend bdd bdd_true(void); + friend bdd bdd_false(void); + friend bdd bdd_ithvarpp(int); + friend bdd bdd_nithvarpp(int); + friend int bdd_var(const bdd &); + friend bdd bdd_low(const bdd &); + friend bdd bdd_high(const bdd &); + friend int bdd_scanset(const bdd &, int *&, int &); + friend bdd bdd_makesetpp(int *, int); + friend int bdd_setbddpair(bddPair*, int, const bdd &); + friend int bdd_setbddpairs(bddPair*, int*, const bdd *, int); + friend bdd bdd_buildcube(int, int, const bdd *); + friend bdd bdd_ibuildcubepp(int, int, int *); + friend bdd bdd_not(const bdd &); + friend bdd bdd_simplify(const bdd &, const bdd &); + friend bdd bdd_apply(const bdd &, const bdd &, int); + friend bdd bdd_and(const bdd &, const bdd &); + friend bdd bdd_or(const bdd &, const bdd &); + friend bdd bdd_xor(const bdd &, const bdd &); + friend bdd bdd_imp(const bdd &, const bdd &); + friend bdd bdd_biimp(const bdd &, const bdd &); + friend bdd bdd_ite(const bdd &, const bdd &, const bdd &); + friend bdd bdd_restrict(const bdd &, const bdd &); + friend bdd bdd_constrain(const bdd &, const bdd &); + friend bdd bdd_exist(const bdd &, const bdd &); + friend bdd bdd_project(const bdd &, const bdd &); + friend bdd bdd_forall(const bdd &, const bdd &); + friend bdd bdd_unique(const bdd &, const bdd &); + friend bdd bdd_appex(const bdd &, const bdd &, int, const bdd &); + friend bdd bdd_appall(const bdd &, const bdd &, int, const bdd &); + friend bdd bdd_appuni(const bdd &, const bdd &, int, const bdd &); + friend bdd bdd_replace(const bdd &, bddPair*); + friend bdd bdd_compose(const bdd &, const bdd &, int); + friend bdd bdd_veccompose(const bdd &, bddPair*); + friend bdd bdd_support(const bdd &); + friend bdd bdd_satone(const bdd &); + friend bdd bdd_satoneset(const bdd &, const bdd &, const bdd &); + friend bdd bdd_fullsatone(const bdd &); + friend void bdd_allsat(const bdd &r, bddallsathandler handler); + friend double bdd_satcount(const bdd &); + friend double bdd_satcountset(const bdd &, const bdd &); + friend double bdd_satcountln(const bdd &); + friend double bdd_satcountlnset(const bdd &, const bdd &); + friend int bdd_nodecount(const bdd &); + friend int bdd_anodecountpp(const bdd *, int); + friend int* bdd_varprofile(const bdd &); + friend double bdd_pathcount(const bdd &); + + friend void bdd_fprinttable(FILE *, const bdd &); + friend void bdd_printtable(const bdd &); + friend void bdd_fprintset(FILE *, const bdd &); + friend void bdd_printset(const bdd &); + friend void bdd_printdot(const bdd &); + friend int bdd_fnprintdot(char*, const bdd &); + friend void bdd_fprintdot(FILE*, const bdd &); + friend std::ostream &operator<<(std::ostream &, const bdd &); + friend int bdd_fnsave(char*, const bdd &); + friend int bdd_save(FILE*, const bdd &); + friend int bdd_fnload(char*, bdd &); + friend int bdd_load(FILE*, bdd &); + + friend bdd fdd_ithvarpp(int, int); + friend bdd fdd_ithsetpp(int); + friend bdd fdd_domainpp(int); + friend int fdd_scanvar(const bdd &, int); + friend int* fdd_scanallvar(const bdd &); + friend bdd fdd_equalspp(int, int); + friend void fdd_printset(const bdd &); + friend void fdd_fprintset(FILE*, const bdd &); + friend bdd fdd_makesetpp(int*, int); + friend int fdd_scanset(const bdd &, int *&, int &); + + friend int bdd_addvarblock(const bdd &, int); + + friend class bvec; + friend bvec bvec_ite(const bdd& a, const bvec& b, const bvec& c); + friend bvec bvec_shlfixed(const bvec &e, int pos, const bdd &c); + friend bvec bvec_shl(const bvec &left, const bvec &right, const bdd &c); + friend bvec bvec_shrfixed(const bvec &e, int pos, const bdd &c); + friend bvec bvec_shr(const bvec &left, const bvec &right, const bdd &c); + friend bdd bvec_lth(const bvec &left, const bvec &right); + friend bdd bvec_lte(const bvec &left, const bvec &right); + friend bdd bvec_gth(const bvec &left, const bvec &right); + friend bdd bvec_gte(const bvec &left, const bvec &right); + friend bdd bvec_equ(const bvec &left, const bvec &right); + friend bdd bvec_neq(const bvec &left, const bvec &right); +}; + + +/*=== BDD constants ====================================================*/ + +extern const bdd bddfalsepp; +extern const bdd bddtruepp; + +#define bddtrue bddtruepp +#define bddfalse bddfalsepp + +/*=== C++ interface ====================================================*/ + +extern int bdd_cpp_init(int, int); + +inline void bdd_stats(bddStat& s) +{ bdd_stats(&s); } + +inline bdd bdd_ithvarpp(int v) +{ return bdd_ithvar(v); } + +inline bdd bdd_nithvarpp(int v) +{ return bdd_nithvar(v); } + +inline int bdd_var(const bdd &r) +{ return bdd_var(r.root); } + +inline bdd bdd_low(const bdd &r) +{ return bdd_low(r.root); } + +inline bdd bdd_high(const bdd &r) +{ return bdd_high(r.root); } + +inline int bdd_scanset(const bdd &r, int *&v, int &n) +{ return bdd_scanset(r.root, &v, &n); } + +inline bdd bdd_makesetpp(int *v, int n) +{ return bdd(bdd_makeset(v,n)); } + +inline int bdd_setbddpair(bddPair *p, int ov, const bdd &nv) +{ return bdd_setbddpair(p,ov,nv.root); } + + /* In bddop.c */ + +inline bdd bdd_replace(const bdd &r, bddPair *p) +{ return bdd_replace(r.root, p); } + +inline bdd bdd_compose(const bdd &f, const bdd &g, int v) +{ return bdd_compose(f.root, g.root, v); } + +inline bdd bdd_veccompose(const bdd &f, bddPair *p) +{ return bdd_veccompose(f.root, p); } + +inline bdd bdd_restrict(const bdd &r, const bdd &var) +{ return bdd_restrict(r.root, var.root); } + +inline bdd bdd_constrain(const bdd &f, const bdd &c) +{ return bdd_constrain(f.root, c.root); } + +inline bdd bdd_simplify(const bdd &d, const bdd &b) +{ return bdd_simplify(d.root, b.root); } + +inline bdd bdd_ibuildcubepp(int v, int w, int *a) +{ return bdd_ibuildcube(v,w,a); } + +inline bdd bdd_not(const bdd &r) +{ return bdd_not(r.root); } + +inline bdd bdd_apply(const bdd &l, const bdd &r, int op) +{ return bdd_apply(l.root, r.root, op); } + +inline bdd bdd_and(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_and); } + +inline bdd bdd_or(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_or); } + +inline bdd bdd_xor(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_xor); } + +inline bdd bdd_imp(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_imp); } + +inline bdd bdd_biimp(const bdd &l, const bdd &r) +{ return bdd_apply(l.root, r.root, bddop_biimp); } + +inline bdd bdd_ite(const bdd &f, const bdd &g, const bdd &h) +{ return bdd_ite(f.root, g.root, h.root); } + +inline bdd bdd_exist(const bdd &r, const bdd &var) +{ return bdd_exist(r.root, var.root); } + +inline bdd bdd_project(const bdd &r, const bdd &var) +{ return bdd_project(r.root, var.root); } + +inline bdd bdd_forall(const bdd &r, const bdd &var) +{ return bdd_forall(r.root, var.root); } + +inline bdd bdd_unique(const bdd &r, const bdd &var) +{ return bdd_unique(r.root, var.root); } + +inline bdd bdd_appex(const bdd &l, const bdd &r, int op, const bdd &var) +{ return bdd_appex(l.root, r.root, op, var.root); } + +inline bdd bdd_appall(const bdd &l, const bdd &r, int op, const bdd &var) +{ return bdd_appall(l.root, r.root, op, var.root); } + +inline bdd bdd_appuni(const bdd &l, const bdd &r, int op, const bdd &var) +{ return bdd_appuni(l.root, r.root, op, var.root); } + +inline bdd bdd_support(const bdd &r) +{ return bdd_support(r.root); } + +inline bdd bdd_satone(const bdd &r) +{ return bdd_satone(r.root); } + +inline bdd bdd_satoneset(const bdd &r, const bdd &var, const bdd &pol) +{ return bdd_satoneset(r.root, var.root, pol.root); } + +inline bdd bdd_fullsatone(const bdd &r) +{ return bdd_fullsatone(r.root); } + +inline void bdd_allsat(const bdd &r, bddallsathandler handler) +{ bdd_allsat(r.root, handler); } + +inline double bdd_satcount(const bdd &r) +{ return bdd_satcount(r.root); } + +inline double bdd_satcountset(const bdd &r, const bdd &varset) +{ return bdd_satcountset(r.root, varset.root); } + +inline double bdd_satcountln(const bdd &r) +{ return bdd_satcountln(r.root); } + +inline double bdd_satcountlnset(const bdd &r, const bdd &varset) +{ return bdd_satcountlnset(r.root, varset.root); } + +inline int bdd_nodecount(const bdd &r) +{ return bdd_nodecount(r.root); } + +inline int* bdd_varprofile(const bdd &r) +{ return bdd_varprofile(r.root); } + +inline double bdd_pathcount(const bdd &r) +{ return bdd_pathcount(r.root); } + + + /* I/O extensions */ + +inline void bdd_fprinttable(FILE *file, const bdd &r) +{ bdd_fprinttable(file, r.root); } + +inline void bdd_printtable(const bdd &r) +{ bdd_printtable(r.root); } + +inline void bdd_fprintset(FILE *file, const bdd &r) +{ bdd_fprintset(file, r.root); } + +inline void bdd_printset(const bdd &r) +{ bdd_printset(r.root); } + +inline void bdd_printdot(const bdd &r) +{ bdd_printdot(r.root); } + +inline void bdd_fprintdot(FILE* ofile, const bdd &r) +{ bdd_fprintdot(ofile, r.root); } + +inline int bdd_fnprintdot(char* fname, const bdd &r) +{ return bdd_fnprintdot(fname, r.root); } + +inline int bdd_fnsave(char *fname, const bdd &r) +{ return bdd_fnsave(fname, r.root); } + +inline int bdd_save(FILE *ofile, const bdd &r) +{ return bdd_save(ofile, r.root); } + +inline int bdd_fnload(char *fname, bdd &r) +{ int lr,e; e=bdd_fnload(fname, &lr); r=bdd(lr); return e; } + +inline int bdd_load(FILE *ifile, bdd &r) +{ int lr,e; e=bdd_load(ifile, &lr); r=bdd(lr); return e; } + +inline int bdd_addvarblock(const bdd &v, int f) +{ return bdd_addvarblock(v.root, f); } + + /* Hack to allow for overloading */ +#define bdd_init bdd_cpp_init +#define bdd_ithvar bdd_ithvarpp +#define bdd_nithvar bdd_nithvarpp +#define bdd_makeset bdd_makesetpp +#define bdd_ibuildcube bdd_ibuildcubepp +#define bdd_anodecount bdd_anodecountpp + +/*=== Inline C++ functions =============================================*/ + +inline int bdd::id(void) const +{ return root; } + +inline bdd bdd::operator&(const bdd &r) const +{ return bdd_apply(*this,r,bddop_and); } + +inline bdd bdd::operator&=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_and)); } + +inline bdd bdd::operator^(const bdd &r) const +{ return bdd_apply(*this,r,bddop_xor); } + +inline bdd bdd::operator^=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_xor)); } + +inline bdd bdd::operator|(const bdd &r) const +{ return bdd_apply(*this,r,bddop_or); } + +inline bdd bdd::operator|=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_or)); } + +inline bdd bdd::operator!(void) const +{ return bdd_not(*this);} + +inline bdd bdd::operator>>(const bdd &r) const +{ return bdd_apply(*this,r,bddop_imp); } + +inline bdd bdd::operator>>=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_imp)); } + +inline bdd bdd::operator-(const bdd &r) const +{ return bdd_apply(*this,r,bddop_diff); } + +inline bdd bdd::operator-=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_diff)); } + +inline bdd bdd::operator>(const bdd &r) const +{ return bdd_apply(*this,r,bddop_diff); } + +inline bdd bdd::operator<(const bdd &r) const +{ return bdd_apply(*this,r,bddop_less); } + +inline bdd bdd::operator<<(const bdd &r) const +{ return bdd_apply(*this,r,bddop_invimp); } + +inline bdd bdd::operator<<=(const bdd &r) +{ return (*this=bdd_apply(*this,r,bddop_invimp)); } + +inline int bdd::operator==(const bdd &r) const +{ return r.root==root; } + +inline int bdd::operator!=(const bdd &r) const +{ return r.root!=root; } + +inline bdd bdd_true(void) +{ return 1; } + +inline bdd bdd_false(void) +{ return 0; } + + +/*=== Iostream printing ================================================*/ + +class bdd_ioformat +{ + public: + bdd_ioformat(int f) { format=f; } + private: + bdd_ioformat(void) { } + int format; + static int curformat; + + friend std::ostream &operator<<(std::ostream &, const bdd_ioformat &); + friend std::ostream &operator<<(std::ostream &, const bdd &); +}; + +std::ostream &operator<<(std::ostream &, const bdd &); +std::ostream &operator<<(std::ostream &, const bdd_ioformat &); + +extern bdd_ioformat bddset; +extern bdd_ioformat bddtable; +extern bdd_ioformat bdddot; +extern bdd_ioformat bddall; +extern bdd_ioformat fddset; + +typedef void (*bddstrmhandler)(std::ostream &, int); + +extern bddstrmhandler bdd_strm_hook(bddstrmhandler); + +#endif /* CPLUSPLUS */ + +#endif /* _BDD_H */ + +/* EOF */ diff --git a/sdk/buddy-2.4/src/bddio.c b/sdk/buddy-2.4/src/bddio.c new file mode 100644 index 0000000..b4d4c64 --- /dev/null +++ b/sdk/buddy-2.4/src/bddio.c @@ -0,0 +1,593 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bddio.c,v 1.1.1.1 2004/06/25 13:22:14 haimcohen Exp $ + FILE: bddio.c + DESCR: File I/O routines for BDD package + AUTH: Jorn Lind + DATE: (C) june 1997 +*************************************************************************/ +#include +#include +#include +#include +#include +#include "kernel.h" + +static void bdd_printset_rec(FILE *, int, int *); +static void bdd_fprintdot_rec(FILE*, BDD); +static int bdd_save_rec(FILE*, int); +static int bdd_loaddata(FILE *); +static int loadhash_get(int); +static void loadhash_add(int, int); + +static bddfilehandler filehandler; + +typedef struct s_LoadHash +{ + int key; + int data; + int first; + int next; +} LoadHash; + +static LoadHash *lh_table; +static int lh_freepos; +static int lh_nodenum; +static int *loadvar2level; + +/*=== PRINTING ========================================================*/ + + +/* +NAME {* bdd\_file\_hook *} +SECTION {* kernel *} +SHORT {* Specifies a printing callback handler *} +PROTO {* bddfilehandler bdd_file_hook(bddfilehandler handler) *} +DESCR {* A printing callback handler for use with BDDs is used to + convert the BDD variable number into something readable by the + end user. Typically the handler will print a string name + instead of the number. A handler could look like this: + \begin{verbatim} +void printhandler(FILE *o, int var) +{ + extern char **names; + fprintf(o, "%s", names[var]); +} +\end{verbatim} + + \noindent + The handler can then be passed to BuDDy like this: + {\tt bdd\_file\_hook(printhandler)}. + + No default handler is supplied. The argument {\tt handler} may be + NULL if no handler is needed. *} +RETURN {* The old handler *} +ALSO {* bdd\_printset, bdd\_strm\_hook, fdd\_file\_hook *} +*/ +bddfilehandler bdd_file_hook(bddfilehandler handler) +{ + bddfilehandler old = filehandler; + filehandler = handler; + return old; +} + + +/* +NAME {* bdd\_printall *} +EXTRA {* bdd\_fprintall *} +SECTION {* fileio *} +SHORT {* prints all used entries in the node table *} +PROTO {* void bdd_printall(void) +void bdd_fprintall(FILE* ofile) *} +DESCR {* Prints to either stdout or the file {\tt ofile} all the used + entries in the main node table. The format is: + \begin{Ill} + {\tt [Nodenum] Var/level Low High} + \end{Ill} + Where {\tt Nodenum} is the position in the node table and level + is the position in the current variable order. *} +ALSO {* bdd\_printtable, bdd\_printset, bdd\_printdot *} +*/ +void bdd_printall(void) +{ + bdd_fprintall(stdout); +} + + +void bdd_fprintall(FILE *ofile) +{ + int n; + + for (n=0 ; n\\ + < $x_{2,1}:c_{2,1},\ldots,x_{2,n_2}:c_{2,n_2}$ >\\ + $\ldots$ \\ + < $x_{N,1}:c_{N,1},\ldots,x_{N,n_3}:c_{N,n_3}$ > } + \end{Ill} + Where the $x$'s are variable numbers (and the position in the + current order) and the $c$'s are the + possible assignments to these. Each set of brackets designates + one possible assignment to the set of variables that make up the + BDD. All variables not shown are don't cares. It is possible to + specify a callback handler for printing of the variables using + {\tt bdd\_file\_hook} or {\tt bdd\_strm\_hook}. *} +ALSO {* bdd\_printall, bdd\_printtable, bdd\_printdot, bdd\_file\_hook, bdd\_strm\_hook *} +*/ +void bdd_printset(BDD r) +{ + bdd_fprintset(stdout, r); +} + + +void bdd_fprintset(FILE *ofile, BDD r) +{ + int *set; + + if (r < 2) + { + fprintf(ofile, "%s", r == 0 ? "F" : "T"); + return; + } + + if ((set=(int *)malloc(sizeof(int)*bddvarnum)) == NULL) + { + bdd_error(BDD_MEMORY); + return; + } + + memset(set, 0, sizeof(int) * bddvarnum); + bdd_printset_rec(ofile, r, set); + free(set); +} + + +static void bdd_printset_rec(FILE *ofile, int r, int *set) +{ + int n; + int first; + + if (r == 0) + return; + else + if (r == 1) + { + fprintf(ofile, "<"); + first = 1; + + for (n=0 ; n 0) + { + if (!first) + fprintf(ofile, ", "); + first = 0; + if (filehandler) + filehandler(ofile, bddlevel2var[n]); + else + fprintf(ofile, "%d", bddlevel2var[n]); + fprintf(ofile, ":%d", (set[n]==2 ? 1 : 0)); + } + } + + fprintf(ofile, ">"); + } + else + { + set[LEVEL(r)] = 1; + bdd_printset_rec(ofile, LOW(r), set); + + set[LEVEL(r)] = 2; + bdd_printset_rec(ofile, HIGH(r), set); + + set[LEVEL(r)] = 0; + } +} + + +/* +NAME {* bdd\_printdot *} +EXTRA {* bdd\_fprintdot *} +SECTION {* fileio *} +SHORT {* prints a description of a BDD in DOT format *} +PROTO {* void bdd_printdot(BDD r) +int bdd_fnprintdot(char* fname, BDD r) +void bdd_fprintdot(FILE* ofile, BDD r) *} +DESCR {* Prints a BDD in a format suitable for use with the graph + drawing program DOT to either stdout, a designated file + {\tt ofile} or the file named by {\tt fname}. In the last case + the file will be opened for writing, any previous contents + destroyed and then closed again. *} +ALSO {* bdd\_printall, bdd\_printtable, bdd\_printset *} +*/ +void bdd_printdot(BDD r) +{ + bdd_fprintdot(stdout, r); +} + + +int bdd_fnprintdot(char *fname, BDD r) +{ + FILE *ofile = fopen(fname, "w"); + if (ofile == NULL) + return bdd_error(BDD_FILE); + bdd_fprintdot(ofile, r); + fclose(ofile); + return 0; +} + + +void bdd_fprintdot(FILE* ofile, BDD r) +{ + fprintf(ofile, "digraph G {\n"); + fprintf(ofile, "0 [shape=box, label=\"0\", style=filled, shape=box, height=0.3, width=0.3];\n"); + fprintf(ofile, "1 [shape=box, label=\"1\", style=filled, shape=box, height=0.3, width=0.3];\n"); + + bdd_fprintdot_rec(ofile, r); + + fprintf(ofile, "}\n"); + + bdd_unmark(r); +} + + +static void bdd_fprintdot_rec(FILE* ofile, BDD r) +{ + if (ISCONST(r) || MARKED(r)) + return; + + fprintf(ofile, "%d [label=\"", r); + if (filehandler) + filehandler(ofile, bddlevel2var[LEVEL(r)]); + else + fprintf(ofile, "%d", bddlevel2var[LEVEL(r)]); + fprintf(ofile, "\"];\n"); + + fprintf(ofile, "%d -> %d [style=dotted];\n", r, LOW(r)); + fprintf(ofile, "%d -> %d [style=filled];\n", r, HIGH(r)); + + SETMARK(r); + + bdd_fprintdot_rec(ofile, LOW(r)); + bdd_fprintdot_rec(ofile, HIGH(r)); +} + + +/*=== SAVE =============================================================*/ + +/* +NAME {* bdd\_save *} +EXTRA {* bdd\_fnsave *} +SECTION {* fileio *} +SHORT {* saves a BDD to a file *} +PROTO {* int bdd_fnsave(char *fname, BDD r) +int bdd_save(FILE *ofile, BDD r) *} +DESCR {* Saves the nodes used by {\tt r} to either a file {\tt ofile} + which must be opened for writing or to the file named {\tt fname}. + In the last case the file will be truncated and opened for + writing. *} +ALSO {* bdd\_load *} +RETURN {* Zero on succes, otherwise an error code from {\tt bdd.h}. *} +*/ +int bdd_fnsave(char *fname, BDD r) +{ + FILE *ofile; + int ok; + + if ((ofile=fopen(fname,"w")) == NULL) + return bdd_error(BDD_FILE); + + ok = bdd_save(ofile, r); + fclose(ofile); + return ok; +} + + +int bdd_save(FILE *ofile, BDD r) +{ + int err, n=0; + + if (r < 2) + { + fprintf(ofile, "0 0 %d\n", r); + return 0; + } + + bdd_markcount(r, &n); + bdd_unmark(r); + fprintf(ofile, "%d %d\n", n, bddvarnum); + + for (n=0 ; n bddvarnum) + bdd_setvarnum(vnum); + + if ((lh_table=(LoadHash*)malloc(lh_nodenum*sizeof(LoadHash))) == NULL) + return bdd_error(BDD_MEMORY); + + for (n=0 ; n= 2) + low = loadhash_get(low); + if (high >= 2) + high = loadhash_get(high); + + if (low<0 || high<0 || var<0) + return bdd_error(BDD_FORMAT); + + root = bdd_addref( bdd_ite(bdd_ithvar(var), high, low) ); + + loadhash_add(key, root); + } + + return root; +} + + +static void loadhash_add(int key, int data) +{ + int hash = key % lh_nodenum; + int pos = lh_freepos; + + lh_freepos = lh_table[pos].next; + lh_table[pos].next = lh_table[hash].first; + lh_table[hash].first = pos; + + lh_table[pos].key = key; + lh_table[pos].data = data; +} + + +static int loadhash_get(int key) +{ + int hash = lh_table[key % lh_nodenum].first; + + while (hash != -1 && lh_table[hash].key != key) + hash = lh_table[hash].next; + + if (hash == -1) + return -1; + return lh_table[hash].data; +} + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/bddop.c b/sdk/buddy-2.4/src/bddop.c new file mode 100644 index 0000000..6aba2cc --- /dev/null +++ b/sdk/buddy-2.4/src/bddop.c @@ -0,0 +1,2924 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bddop.c,v 1.1.1.1 2004/06/25 13:22:22 haimcohen Exp $ + FILE: bddop.c + DESCR: BDD operators + AUTH: Jorn Lind + DATE: (C) nov 1997 +*************************************************************************/ +#include +#include +#include +#include +#include + +#include "kernel.h" +#include "cache.h" + + /* Hash value modifiers to distinguish between entries in misccache */ +#define CACHEID_CONSTRAIN 0x0 +#define CACHEID_RESTRICT 0x1 +#define CACHEID_SATCOU 0x2 +#define CACHEID_SATCOULN 0x3 +#define CACHEID_PATHCOU 0x4 + + /* Hash value modifiers for replace/compose */ +#define CACHEID_REPLACE 0x0 +#define CACHEID_COMPOSE 0x1 +#define CACHEID_VECCOMPOSE 0x2 + + /* Hash value modifiers for quantification */ +#define CACHEID_EXIST 0x0 +#define CACHEID_FORALL 0x1 +#define CACHEID_UNIQUE 0x2 +#define CACHEID_APPEX 0x3 +#define CACHEID_APPAL 0x4 +#define CACHEID_APPUN 0x5 +#define CACHEID_PROJECT 0x6 + + + /* Number of boolean operators */ +#define OPERATOR_NUM 11 + + /* Operator results - entry = left<<1 | right (left,right in {0,1}) */ +static int oprres[OPERATOR_NUM][4] = +{ {0,0,0,1}, /* and ( & ) */ + {0,1,1,0}, /* xor ( ^ ) */ + {0,1,1,1}, /* or ( | ) */ + {1,1,1,0}, /* nand */ + {1,0,0,0}, /* nor */ + {1,1,0,1}, /* implication ( >> ) */ + {1,0,0,1}, /* bi-implication */ + {0,0,1,0}, /* difference /greater than ( - ) ( > ) */ + {0,1,0,0}, /* less than ( < ) */ + {1,0,1,1}, /* inverse implication ( << ) */ + {1,1,0,0} /* not ( ! ) */ +}; + + + /* Variables needed for the operators */ +static int applyop; /* Current operator for apply */ +static int appexop; /* Current operator for appex */ +static int appexid; /* Current cache id for appex */ +static int quantid; /* Current cache id for quantifications */ +static int *quantvarset; /* Current variable set for quant. */ +static int quantvarsetID; /* Current id used in quantvarset */ +static int quantlast; /* Current last variable to be quant. */ +static int replaceid; /* Current cache id for replace */ +static int *replacepair; /* Current replace pair */ +static int replacelast; /* Current last var. level to replace */ +static int composelevel; /* Current variable used for compose */ +static int miscid; /* Current cache id for other results */ +static int *varprofile; /* Current variable profile */ +static int supportID; /* Current ID (true value) for support */ +static int supportMin; /* Min. used level in support calc. */ +static int supportMax; /* Max. used level in support calc. */ +static int* supportSet; /* The found support set */ +static BddCache applycache; /* Cache for apply results */ +static BddCache itecache; /* Cache for ITE results */ +static BddCache quantcache; /* Cache for exist/forall results */ +static BddCache appexcache; /* Cache for appex/appall results */ +static BddCache replacecache; /* Cache for replace results */ +static BddCache misccache; /* Cache for other results */ +static int cacheratio; +static BDD satPolarity; +static int firstReorder; /* Used instead of local variable in order + to avoid compiler warning about 'first' + being clobbered by setjmp */ + +static char* allsatProfile; /* Variable profile for bdd_allsat() */ +static bddallsathandler allsatHandler; /* Callback handler for bdd_allsat() */ + +extern bddCacheStat bddcachestats; + + /* Internal prototypes */ +static BDD not_rec(BDD); +static BDD apply_rec(BDD, BDD); +static BDD ite_rec(BDD, BDD, BDD); +static int simplify_rec(BDD, BDD); +static int quant_rec(int); +static int project_rec(int); +static int appquant_rec(int, int); +static int restrict_rec(int); +static BDD constrain_rec(BDD, BDD); +static BDD replace_rec(BDD); +static BDD bdd_correctify(int, BDD, BDD); +static BDD compose_rec(BDD, BDD); +static BDD veccompose_rec(BDD); +static void support_rec(int, int*); +static BDD satone_rec(BDD); +static BDD satoneset_rec(BDD, BDD); +static int fullsatone_rec(int); +static void allsat_rec(BDD r); +static double satcount_rec(int); +static double satcountln_rec(int); +static void varprofile_rec(int); +static double bdd_pathcount_rec(BDD); +static int varset2vartable(BDD); +static int varset2svartable(BDD); + + + /* Hashvalues */ +#define NOTHASH(r) (r) +#define APPLYHASH(l,r,op) (TRIPLE(l,r,op)) +#define ITEHASH(f,g,h) (TRIPLE(f,g,h)) +#define RESTRHASH(r,var) (PAIR(r,var)) +#define CONSTRAINHASH(f,c) (PAIR(f,c)) +#define QUANTHASH(r) (r) +#define REPLACEHASH(r) (r) +#define VECCOMPOSEHASH(f) (f) +#define COMPOSEHASH(f,g) (PAIR(f,g)) +#define SATCOUHASH(r) (r) +#define PATHCOUHASH(r) (r) +#define APPEXHASH(l,r,op) (PAIR(l,r)) + +#ifndef M_LN2 +#define M_LN2 0.69314718055994530942 +#endif + +#define log1p(a) (log(1.0+a)) + +#define INVARSET(a) (quantvarset[a] == quantvarsetID) /* unsigned check */ +#define INSVARSET(a) (abs(quantvarset[a]) == quantvarsetID) /* signed check */ + +/************************************************************************* + Setup and shutdown +*************************************************************************/ + +int bdd_operator_init(int cachesize) +{ + if (BddCache_init(&applycache,cachesize) < 0) + return bdd_error(BDD_MEMORY); + + if (BddCache_init(&itecache,cachesize) < 0) + return bdd_error(BDD_MEMORY); + + if (BddCache_init(&quantcache,cachesize) < 0) + return bdd_error(BDD_MEMORY); + + if (BddCache_init(&appexcache,cachesize) < 0) + return bdd_error(BDD_MEMORY); + + if (BddCache_init(&replacecache,cachesize) < 0) + return bdd_error(BDD_MEMORY); + + if (BddCache_init(&misccache,cachesize) < 0) + return bdd_error(BDD_MEMORY); + + quantvarsetID = 0; + quantvarset = NULL; + cacheratio = 0; + supportSet = NULL; + + return 0; +} + + +void bdd_operator_done(void) +{ + if (quantvarset != NULL) + free(quantvarset); + + BddCache_done(&applycache); + BddCache_done(&itecache); + BddCache_done(&quantcache); + BddCache_done(&appexcache); + BddCache_done(&replacecache); + BddCache_done(&misccache); + + if (supportSet != NULL) + free(supportSet); +} + + +void bdd_operator_reset(void) +{ + BddCache_reset(&applycache); + BddCache_reset(&itecache); + BddCache_reset(&quantcache); + BddCache_reset(&appexcache); + BddCache_reset(&replacecache); + BddCache_reset(&misccache); +} + + +void bdd_operator_varresize(void) +{ + if (quantvarset != NULL) + free(quantvarset); + + if ((quantvarset=NEW(int,bddvarnum)) == NULL) + bdd_error(BDD_MEMORY); + + memset(quantvarset, 0, sizeof(int)*bddvarnum); + quantvarsetID = 0; +} + + +static void bdd_operator_noderesize(void) +{ + if (cacheratio > 0) + { + int newcachesize = bddnodesize / cacheratio; + + BddCache_resize(&applycache, newcachesize); + BddCache_resize(&itecache, newcachesize); + BddCache_resize(&quantcache, newcachesize); + BddCache_resize(&appexcache, newcachesize); + BddCache_resize(&replacecache, newcachesize); + BddCache_resize(&misccache, newcachesize); + } +} + + +/************************************************************************* + Other +*************************************************************************/ + +/* +NAME {* bdd\_setcacheratio *} +SECTION {* kernel *} +SHORT {* Sets the cache ratio for the operator caches *} +PROTO {* int bdd_setcacheratio(int r) *} +DESCR {* The ratio between the number of nodes in the nodetable + and the number of entries in the operator cachetables is called + the cache ratio. So a cache ratio of say, four, allocates one cache + entry for each four unique node entries. This value can be set with + {\tt bdd\_setcacheratio} to any positive value. When this is done + the caches are resized instantly to fit the new ratio. + The default is a fixed cache size determined at + initialization time. *} +RETURN {* The previous cache ratio or a negative number on error. *} +ALSO {* bdd\_init *} +*/ +int bdd_setcacheratio(int r) +{ + int old = cacheratio; + + if (r <= 0) + return bdd_error(BDD_RANGE); + if (bddnodesize == 0) + return old; + + cacheratio = r; + bdd_operator_noderesize(); + return old; +} + + +/************************************************************************* + Operators +*************************************************************************/ + +static void checkresize(void) +{ + if (bddresized) + bdd_operator_noderesize(); + bddresized = 0; +} + + +/*=== BUILD A CUBE =====================================================*/ + +/* +NAME {* bdd\_buildcube *} +EXTRA {* bdd\_ibuildcube *} +SECTION {* operator *} +SHORT {* build a cube from an array of variables *} +PROTO {* BDD bdd_buildcube(int value, int width, BDD *var) +BDD bdd_ibuildcube(int value, int width, int *var)*} +DESCR {* This function builds a cube from the variables in {\tt + var}. It does so by interpreting the {\tt width} low order + bits of {\tt value} as a bit mask--a set bit indicates that the + variable should be added in it's positive form, and a cleared + bit the opposite. The most significant bits are encoded with + the first variables in {\tt var}. Consider as an example + the call {\tt bdd\_buildcube(0xB, 4, var)}. This corresponds + to the expression: $var[0] \conj \neg var[1] \conj var[2] + \conj var[3]$. The first version of the function takes an array + of BDDs, whereas the second takes an array of variable numbers + as used in {\tt bdd\_ithvar}. *} +RETURN {* The resulting cube *} +ALSO {* bdd\_ithvar, fdd\_ithvar *} +*/ +BDD bdd_buildcube(int value, int width, BDD *variables) +{ + BDD result = BDDONE; + int z; + + for (z=0 ; z>=1) + { + BDD tmp; + BDD v; + + if (value & 0x1) + v = bdd_addref( variables[width-z-1] ); + else + v = bdd_addref( bdd_not(variables[width-z-1]) ); + + bdd_addref(result); + tmp = bdd_apply(result,v,bddop_and); + bdd_delref(result); + bdd_delref(v); + + result = tmp; + } + + return result; +} + + +BDD bdd_ibuildcube(int value, int width, int *variables) +{ + BDD result = BDDONE; + int z; + + for (z=0 ; z>=1) + { + BDD tmp; + BDD v; + + if (value & 0x1) + v = bdd_ithvar(variables[width-z-1]); + else + v = bdd_nithvar(variables[width-z-1]); + + bdd_addref(result); + tmp = bdd_apply(result,v,bddop_and); + bdd_delref(result); + + result = tmp; + } + + return result; +} + + +/*=== NOT ==============================================================*/ + +/* +NAME {* bdd\_not *} +SECTION {* operator *} +SHORT {* negates a bdd *} +PROTO {* BDD bdd_not(BDD r) *} +DESCR {* Negates the BDD {\tt r} by exchanging + all references to the zero-terminal with references to the + one-terminal and vice versa. *} +RETURN {* The negated bdd. *} +*/ +BDD bdd_not(BDD r) +{ + BDD res; + firstReorder = 1; + CHECKa(r, bddfalse); + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + + if (!firstReorder) + bdd_disable_reorder(); + res = not_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD not_rec(BDD r) +{ + BddCacheData *entry; + BDD res; + + if (ISZERO(r)) + return BDDONE; + if (ISONE(r)) + return BDDZERO; + + entry = BddCache_lookup(&applycache, NOTHASH(r)); + + if (entry->a == r && entry->c == bddop_not) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + PUSHREF( not_rec(LOW(r)) ); + PUSHREF( not_rec(HIGH(r)) ); + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + POPREF(2); + + entry->a = r; + entry->c = bddop_not; + entry->r.res = res; + + return res; +} + + +/*=== APPLY ============================================================*/ + +/* +NAME {* bdd\_apply *} +SECTION {* operator *} +SHORT {* basic bdd operations *} +PROTO {* BDD bdd_apply(BDD left, BDD right, int opr) *} +DESCR {* The {\tt bdd\_apply} function performs all of the basic + bdd operations with two operands, such as AND, OR etc. + The {\tt left} argument is the left bdd operand and {\tt right} + is the right operand. The {\tt opr} argument is the requested + operation and must be one of the following\\ + + \begin{tabular}{lllc} + {\bf Identifier} & {\bf Description} & {\bf Truth table} + & {\bf C++ opr.} \\ + {\tt bddop\_and} & logical and ($A \wedge B$) & [0,0,0,1] + & \verb%&% \\ + {\tt bddop\_xor} & logical xor ($A \oplus B$) & [0,1,1,0] + & \verb%^% \\ + {\tt bddop\_or} & logical or ($A \vee B$) & [0,1,1,1] + & \verb%|% \\ + {\tt bddop\_nand} & logical not-and & [1,1,1,0] \\ + {\tt bddop\_nor} & logical not-or & [1,0,0,0] \\ + {\tt bddop\_imp} & implication ($A \Rightarrow B$) & [1,1,0,1] + & \verb%>>% \\ + {\tt bddop\_biimp} & bi-implication ($A \Leftrightarrow B$)& [1,0,0,1] \\ + {\tt bddop\_diff} & set difference ($A \setminus B$) & [0,0,1,0] + & \verb%-% \\ + {\tt bddop\_less} & less than ($A < B$) & [0,1,0,0] + & \verb%<% \\ + {\tt bddop\_invimp} & reverse implication ($A \Leftarrow B$)& [1,0,1,1] + & \verb%<<% \\ + \end{tabular} + *} + RETURN {* The result of the operation. *} + ALSO {* bdd\_ite *} +*/ +BDD bdd_apply(BDD l, BDD r, int op) +{ + BDD res; + firstReorder = 1; + + CHECKa(l, bddfalse); + CHECKa(r, bddfalse); + + if (op<0 || op>bddop_invimp) + { + bdd_error(BDD_OP); + return bddfalse; + } + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + applyop = op; + + if (!firstReorder) + bdd_disable_reorder(); + res = apply_rec(l, r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD apply_rec(BDD l, BDD r) +{ + BddCacheData *entry; + BDD res; + + switch (applyop) + { + case bddop_and: + if (l == r) + return l; + if (ISZERO(l) || ISZERO(r)) + return 0; + if (ISONE(l)) + return r; + if (ISONE(r)) + return l; + break; + case bddop_or: + if (l == r) + return l; + if (ISONE(l) || ISONE(r)) + return 1; + if (ISZERO(l)) + return r; + if (ISZERO(r)) + return l; + break; + case bddop_xor: + if (l == r) + return 0; + if (ISZERO(l)) + return r; + if (ISZERO(r)) + return l; + break; + case bddop_nand: + if (ISZERO(l) || ISZERO(r)) + return 1; + break; + case bddop_nor: + if (ISONE(l) || ISONE(r)) + return 0; + break; + case bddop_imp: + if (ISZERO(l)) + return 1; + if (ISONE(l)) + return r; + if (ISONE(r)) + return 1; + break; + } + + if (ISCONST(l) && ISCONST(r)) + res = oprres[applyop][l<<1 | r]; + else + { + entry = BddCache_lookup(&applycache, APPLYHASH(l,r,applyop)); + + if (entry->a == l && entry->b == r && entry->c == applyop) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (LEVEL(l) == LEVEL(r)) + { + PUSHREF( apply_rec(LOW(l), LOW(r)) ); + PUSHREF( apply_rec(HIGH(l), HIGH(r)) ); + res = bdd_makenode(LEVEL(l), READREF(2), READREF(1)); + } + else + if (LEVEL(l) < LEVEL(r)) + { + PUSHREF( apply_rec(LOW(l), r) ); + PUSHREF( apply_rec(HIGH(l), r) ); + res = bdd_makenode(LEVEL(l), READREF(2), READREF(1)); + } + else + { + PUSHREF( apply_rec(l, LOW(r)) ); + PUSHREF( apply_rec(l, HIGH(r)) ); + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + } + + POPREF(2); + + entry->a = l; + entry->b = r; + entry->c = applyop; + entry->r.res = res; + } + + return res; +} + + +/* +NAME {* bdd\_and *} +SECTION {* operator *} +SHORT {* The logical 'and' of two BDDs *} +PROTO {* BDD bdd_and(BDD l, BDD r) *} +DESCR {* This a wrapper that calls {\tt bdd\_apply(l,r,bddop\_and)}. *} +RETURN {* The logical 'and' of {\tt l} and {\tt r}. *} +ALSO {* bdd\_apply, bdd\_or, bdd\_xor *} +*/ +BDD bdd_and(BDD l, BDD r) +{ + return bdd_apply(l,r,bddop_and); +} + + +/* +NAME {* bdd\_or *} +SECTION {* operator *} +SHORT {* The logical 'or' of two BDDs *} +PROTO {* BDD bdd_or(BDD l, BDD r) *} +DESCR {* This a wrapper that calls {\tt bdd\_apply(l,r,bddop\_or)}. *} +RETURN {* The logical 'or' of {\tt l} and {\tt r}. *} +ALSO {* bdd\_apply, bdd\_xor, bdd\_and *} +*/ +BDD bdd_or(BDD l, BDD r) +{ + return bdd_apply(l,r,bddop_or); +} + + +/* +NAME {* bdd\_xor *} +SECTION {* operator *} +SHORT {* The logical 'xor' of two BDDs *} +PROTO {* BDD bdd_xor(BDD l, BDD r) *} +DESCR {* This a wrapper that calls {\tt bdd\_apply(l,r,bddop\_xor)}. *} +RETURN {* The logical 'xor' of {\tt l} and {\tt r}. *} +ALSO {* bdd\_apply, bdd\_or, bdd\_and *} +*/ +BDD bdd_xor(BDD l, BDD r) +{ + return bdd_apply(l,r,bddop_xor); +} + + +/* +NAME {* bdd\_imp *} +SECTION {* operator *} +SHORT {* The logical 'implication' between two BDDs *} +PROTO {* BDD bdd_imp(BDD l, BDD r) *} +DESCR {* This a wrapper that calls {\tt bdd\_apply(l,r,bddop\_imp)}. *} +RETURN {* The logical 'implication' of {\tt l} and {\tt r} ($l \Rightarrow r$). *} +ALSO {* bdd\_apply, bdd\_biimp *} +*/ +BDD bdd_imp(BDD l, BDD r) +{ + return bdd_apply(l,r,bddop_imp); +} + + +/* +NAME {* bdd\_biimp *} +SECTION {* operator *} +SHORT {* The logical 'bi-implication' between two BDDs *} +PROTO {* BDD bdd_biimp(BDD l, BDD r) *} +DESCR {* This a wrapper that calls {\tt bdd\_apply(l,r,bddop\_biimp)}. *} +RETURN {* The logical 'bi-implication' of {\tt l} and {\tt r} ($l \Leftrightarrow r$). *} +ALSO {* bdd\_apply, bdd\_imp *} +*/ +BDD bdd_biimp(BDD l, BDD r) +{ + return bdd_apply(l,r,bddop_biimp); +} + + +/*=== ITE ==============================================================*/ + +/* +NAME {* bdd\_ite *} +SECTION {* operator *} +SHORT {* if-then-else operator *} +PROTO {* BDD bdd_ite(BDD f, BDD g, BDD h) *} +DESCR {* Calculates the BDD for the expression + $(f \conj g) \disj (\neg f \conj h)$ more efficiently than doing + the three operations separately. {\tt bdd\_ite} can also be used + for conjunction, disjunction and any other boolean operator, but + is not as efficient for the binary and unary operations. *} +RETURN {* The BDD for $(f \conj g) \disj (\neg f \conj h)$ *} +ALSO {* bdd\_apply *} +*/ +BDD bdd_ite(BDD f, BDD g, BDD h) +{ + BDD res; + firstReorder = 1; + + CHECKa(f, bddfalse); + CHECKa(g, bddfalse); + CHECKa(h, bddfalse); + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + + if (!firstReorder) + bdd_disable_reorder(); + res = ite_rec(f,g,h); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD ite_rec(BDD f, BDD g, BDD h) +{ + BddCacheData *entry; + BDD res; + + if (ISONE(f)) + return g; + if (ISZERO(f)) + return h; + if (g == h) + return g; + if (ISONE(g) && ISZERO(h)) + return f; + if (ISZERO(g) && ISONE(h)) + return not_rec(f); + + entry = BddCache_lookup(&itecache, ITEHASH(f,g,h)); + if (entry->a == f && entry->b == g && entry->c == h) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (LEVEL(f) == LEVEL(g)) + { + if (LEVEL(f) == LEVEL(h)) + { + PUSHREF( ite_rec(LOW(f), LOW(g), LOW(h)) ); + PUSHREF( ite_rec(HIGH(f), HIGH(g), HIGH(h)) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + } + else + if (LEVEL(f) < LEVEL(h)) + { + PUSHREF( ite_rec(LOW(f), LOW(g), h) ); + PUSHREF( ite_rec(HIGH(f), HIGH(g), h) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + } + else /* f > h */ + { + PUSHREF( ite_rec(f, g, LOW(h)) ); + PUSHREF( ite_rec(f, g, HIGH(h)) ); + res = bdd_makenode(LEVEL(h), READREF(2), READREF(1)); + } + } + else + if (LEVEL(f) < LEVEL(g)) + { + if (LEVEL(f) == LEVEL(h)) + { + PUSHREF( ite_rec(LOW(f), g, LOW(h)) ); + PUSHREF( ite_rec(HIGH(f), g, HIGH(h)) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + } + else + if (LEVEL(f) < LEVEL(h)) + { + PUSHREF( ite_rec(LOW(f), g, h) ); + PUSHREF( ite_rec(HIGH(f), g, h) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + } + else /* f > h */ + { + PUSHREF( ite_rec(f, g, LOW(h)) ); + PUSHREF( ite_rec(f, g, HIGH(h)) ); + res = bdd_makenode(LEVEL(h), READREF(2), READREF(1)); + } + } + else /* f > g */ + { + if (LEVEL(g) == LEVEL(h)) + { + PUSHREF( ite_rec(f, LOW(g), LOW(h)) ); + PUSHREF( ite_rec(f, HIGH(g), HIGH(h)) ); + res = bdd_makenode(LEVEL(g), READREF(2), READREF(1)); + } + else + if (LEVEL(g) < LEVEL(h)) + { + PUSHREF( ite_rec(f, LOW(g), h) ); + PUSHREF( ite_rec(f, HIGH(g), h) ); + res = bdd_makenode(LEVEL(g), READREF(2), READREF(1)); + } + else /* g > h */ + { + PUSHREF( ite_rec(f, g, LOW(h)) ); + PUSHREF( ite_rec(f, g, HIGH(h)) ); + res = bdd_makenode(LEVEL(h), READREF(2), READREF(1)); + } + } + + POPREF(2); + + entry->a = f; + entry->b = g; + entry->c = h; + entry->r.res = res; + + return res; +} + + +/*=== RESTRICT =========================================================*/ + +/* +NAME {* bdd\_restrict *} +SECTION {* operator *} +SHORT {* restric a set of variables to constant values *} +PROTO {* BDD bdd_restrict(BDD r, BDD var) *} +DESCR {* This function restricts the variables in {\tt r} to constant + true or false. How this is done + depends on how the variables are included in the variable set + {\tt var}. If they + are included in their positive form then they are restricted to + true and vice versa. Unfortunately it is not possible to + insert variables in their negated form using {\tt bdd\_makeset}, + so the variable set has to be build manually as a + conjunction of the variables. Example: Assume variable 1 should be + restricted to true and variable 3 to false. + \begin{verbatim} + bdd X = make_user_bdd(); + bdd R1 = bdd_ithvar(1); + bdd R2 = bdd_nithvar(3); + bdd R = bdd_addref( bdd_apply(R1,R2, bddop_and) ); + bdd RES = bdd_addref( bdd_restrict(X,R) ); +\end{verbatim} + *} +RETURN {* The restricted bdd. *} +ALSO {* bdd\_makeset, bdd\_exist, bdd\_forall *} +*/ +BDD bdd_restrict(BDD r, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(r,bddfalse); + CHECKa(var,bddfalse); + + if (var < 2) /* Empty set */ + return r; + + again: + if (setjmp(bddexception) == 0) + { + if (varset2svartable(var) < 0) + return bddfalse; + + INITREF; + miscid = (var << 3) | CACHEID_RESTRICT; + + if (!firstReorder) + bdd_disable_reorder(); + res = restrict_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static int restrict_rec(int r) +{ + BddCacheData *entry; + int res; + + if (ISCONST(r) || LEVEL(r) > quantlast) + return r; + + entry = BddCache_lookup(&misccache, RESTRHASH(r,miscid)); + if (entry->a == r && entry->c == miscid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (INSVARSET(LEVEL(r))) + { + if (quantvarset[LEVEL(r)] > 0) + res = restrict_rec(HIGH(r)); + else + res = restrict_rec(LOW(r)); + } + else + { + PUSHREF( restrict_rec(LOW(r)) ); + PUSHREF( restrict_rec(HIGH(r)) ); + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + POPREF(2); + } + + entry->a = r; + entry->c = miscid; + entry->r.res = res; + + return res; +} + + +/*=== GENERALIZED COFACTOR =============================================*/ + +/* +NAME {* bdd\_constrain *} +SECTION {* operator *} +SHORT {* generalized cofactor *} +PROTO {* BDD bdd_constrain(BDD f, BDD c) *} +DESCR {* Computes the generalized cofactor of {\tt f} with respect to + {\tt c}. *} +RETURN {* The constrained BDD *} +ALSO {* bdd\_restrict, bdd\_simplify *} +*/ +BDD bdd_constrain(BDD f, BDD c) +{ + BDD res; + firstReorder = 1; + + CHECKa(f,bddfalse); + CHECKa(c,bddfalse); + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + miscid = CACHEID_CONSTRAIN; + + if (!firstReorder) + bdd_disable_reorder(); + res = constrain_rec(f, c); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD constrain_rec(BDD f, BDD c) +{ + BddCacheData *entry; + BDD res; + + if (ISONE(c)) + return f; + if (ISCONST(f)) + return f; + if (c == f) + return BDDONE; + if (ISZERO(c)) + return BDDZERO; + + entry = BddCache_lookup(&misccache, CONSTRAINHASH(f,c)); + if (entry->a == f && entry->b == c && entry->c == miscid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (LEVEL(f) == LEVEL(c)) + { + if (ISZERO(LOW(c))) + res = constrain_rec(HIGH(f), HIGH(c)); + else if (ISZERO(HIGH(c))) + res = constrain_rec(LOW(f), LOW(c)); + else + { + PUSHREF( constrain_rec(LOW(f), LOW(c)) ); + PUSHREF( constrain_rec(HIGH(f), HIGH(c)) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + POPREF(2); + } + } + else + if (LEVEL(f) < LEVEL(c)) + { + PUSHREF( constrain_rec(LOW(f), c) ); + PUSHREF( constrain_rec(HIGH(f), c) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + POPREF(2); + } + else + { + if (ISZERO(LOW(c))) + res = constrain_rec(f, HIGH(c)); + else if (ISZERO(HIGH(c))) + res = constrain_rec(f, LOW(c)); + else + { + PUSHREF( constrain_rec(f, LOW(c)) ); + PUSHREF( constrain_rec(f, HIGH(c)) ); + res = bdd_makenode(LEVEL(c), READREF(2), READREF(1)); + POPREF(2); + } + } + + entry->a = f; + entry->b = c; + entry->c = miscid; + entry->r.res = res; + + return res; +} + + +/*=== REPLACE ==========================================================*/ + +/* +NAME {* bdd\_replace *} +SECTION {* operator *} +SHORT {* replaces variables with other variables *} +PROTO {* BDD bdd_replace(BDD r, bddPair *pair) *} +DESCR {* Replaces all variables in the BDD {\tt r} with the variables + defined by {\tt pair}. Each entry in {\tt pair} consists of a + old and a new variable. Whenever the old variable is found in + {\tt r} then a new node with the new variable is inserted instead. + *} +ALSO {* bdd\_newpair, bdd\_setpair, bdd\_setpairs *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_replace(BDD r, bddPair *pair) +{ + BDD res; + firstReorder = 1; + + CHECKa(r, bddfalse); + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + replacepair = pair->result; + replacelast = pair->last; + replaceid = (pair->id << 2) | CACHEID_REPLACE; + + if (!firstReorder) + bdd_disable_reorder(); + res = replace_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD replace_rec(BDD r) +{ + BddCacheData *entry; + BDD res; + + if (ISCONST(r) || LEVEL(r) > replacelast) + return r; + + entry = BddCache_lookup(&replacecache, REPLACEHASH(r)); + if (entry->a == r && entry->c == replaceid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + PUSHREF( replace_rec(LOW(r)) ); + PUSHREF( replace_rec(HIGH(r)) ); + + res = bdd_correctify(LEVEL(replacepair[LEVEL(r)]), READREF(2), READREF(1)); + POPREF(2); + + entry->a = r; + entry->c = replaceid; + entry->r.res = res; + + return res; +} + + +static BDD bdd_correctify(int level, BDD l, BDD r) +{ + BDD res; + + if (level < LEVEL(l) && level < LEVEL(r)) + return bdd_makenode(level, l, r); + + if (level == LEVEL(l) || level == LEVEL(r)) + { + bdd_error(BDD_REPLACE); + return 0; + } + + if (LEVEL(l) == LEVEL(r)) + { + PUSHREF( bdd_correctify(level, LOW(l), LOW(r)) ); + PUSHREF( bdd_correctify(level, HIGH(l), HIGH(r)) ); + res = bdd_makenode(LEVEL(l), READREF(2), READREF(1)); + } + else + if (LEVEL(l) < LEVEL(r)) + { + PUSHREF( bdd_correctify(level, LOW(l), r) ); + PUSHREF( bdd_correctify(level, HIGH(l), r) ); + res = bdd_makenode(LEVEL(l), READREF(2), READREF(1)); + } + else + { + PUSHREF( bdd_correctify(level, l, LOW(r)) ); + PUSHREF( bdd_correctify(level, l, HIGH(r)) ); + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + } + POPREF(2); + + return res; /* FIXME: cache ? */ +} + + +/*=== COMPOSE ==========================================================*/ + +/* +NAME {* bdd\_compose *} +SECTION {* operator *} +SHORT {* functional composition *} +PROTO {* BDD bdd_compose(BDD f, BDD g, int var) *} +DESCR {* Substitutes the variable {\tt var} with the BDD {\tt g} in + the BDD {\tt f}: result $= f[g/var]$. *} +RETURN {* The composed BDD *} +ALSO {* bdd\_veccompose, bdd\_replace, bdd\_restrict *} +*/ +BDD bdd_compose(BDD f, BDD g, int var) +{ + BDD res; + firstReorder = 1; + + CHECKa(f, bddfalse); + CHECKa(g, bddfalse); + if (var < 0 || var >= bddvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + composelevel = bddvar2level[var]; + replaceid = (composelevel << 2) | CACHEID_COMPOSE; + + if (!firstReorder) + bdd_disable_reorder(); + res = compose_rec(f, g); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD compose_rec(BDD f, BDD g) +{ + BddCacheData *entry; + BDD res; + + if (LEVEL(f) > composelevel) + return f; + + entry = BddCache_lookup(&replacecache, COMPOSEHASH(f,g)); + if (entry->a == f && entry->b == g && entry->c == replaceid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (LEVEL(f) < composelevel) + { + if (LEVEL(f) == LEVEL(g)) + { + PUSHREF( compose_rec(LOW(f), LOW(g)) ); + PUSHREF( compose_rec(HIGH(f), HIGH(g)) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + } + else + if (LEVEL(f) < LEVEL(g)) + { + PUSHREF( compose_rec(LOW(f), g) ); + PUSHREF( compose_rec(HIGH(f), g) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + } + else + { + PUSHREF( compose_rec(f, LOW(g)) ); + PUSHREF( compose_rec(f, HIGH(g)) ); + res = bdd_makenode(LEVEL(g), READREF(2), READREF(1)); + } + POPREF(2); + } + else + /*if (LEVEL(f) == composelevel) changed 2-nov-98 */ + { + res = ite_rec(g, HIGH(f), LOW(f)); + } + + entry->a = f; + entry->b = g; + entry->c = replaceid; + entry->r.res = res; + + return res; +} + + +/* +NAME {* bdd\_veccompose *} +SECTION {* operator *} +SHORT {* simultaneous functional composition *} +PROTO {* BDD bdd_veccompose(BDD f, bddPair *pair) *} +DESCR {* Uses the pairs of variables and BDDs in {\tt pair} to make + the simultaneous substitution: $f[g_1/V_1, \ldots, g_n/V_n]$. + In this way one or more BDDs + may be substituted in one step. The BDDs in + {\tt pair} may depend on the variables they are substituting. + {\tt bdd\_compose} may be used instead of + {\tt bdd\_replace} but is not as efficient when $g_i$ is a + single variable, the same applies to {\tt bdd\_restrict}. + Note that simultaneous substitution is not necessarily the same + as repeated substitution. Example: + $(x_1 \disj x_2)[x_3/x_1,x_4/x_3] = (x_3 \disj x_2) \neq + ((x_1 \disj x_2)[x_3/x_1])[x_4/x_3] = (x_4 \disj x_2)$. *} +RETURN {* The composed BDD *} +ALSO {* bdd\_compose, bdd\_replace, bdd\_restrict *} +*/ +BDD bdd_veccompose(BDD f, bddPair *pair) +{ + BDD res; + firstReorder = 1; + + CHECKa(f, bddfalse); + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + replacepair = pair->result; + replaceid = (pair->id << 2) | CACHEID_VECCOMPOSE; + replacelast = pair->last; + + if (!firstReorder) + bdd_disable_reorder(); + res = veccompose_rec(f); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD veccompose_rec(BDD f) +{ + BddCacheData *entry; + register BDD res; + + if (LEVEL(f) > replacelast) + return f; + + entry = BddCache_lookup(&replacecache, VECCOMPOSEHASH(f)); + if (entry->a == f && entry->c == replaceid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + PUSHREF( veccompose_rec(LOW(f)) ); + PUSHREF( veccompose_rec(HIGH(f)) ); + res = ite_rec(replacepair[LEVEL(f)], READREF(1), READREF(2)); + POPREF(2); + + entry->a = f; + entry->c = replaceid; + entry->r.res = res; + + return res; +} + + +/*=== SIMPLIFY =========================================================*/ + +/* +NAME {* bdd\_simplify *} +SECTION {* operator *} +SHORT {* coudert and Madre's restrict function *} +PROTO {* BDD bdd_simplify(BDD f, BDD d) *} +DESCR {* Tries to simplify the BDD {\tt f} by restricting it to the + domaine covered by {\tt d}. No checks are done to see if the + result is actually smaller than the input. This can be done + by the user with a call to {\tt bdd\_nodecount}. *} +ALSO {* bdd\_restrict *} +RETURN {* The simplified BDD *} +*/ +BDD bdd_simplify(BDD f, BDD d) +{ + BDD res; + firstReorder = 1; + + CHECKa(f, bddfalse); + CHECKa(d, bddfalse); + + again: + if (setjmp(bddexception) == 0) + { + INITREF; + applyop = bddop_or; + + if (!firstReorder) + bdd_disable_reorder(); + res = simplify_rec(f, d); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static BDD simplify_rec(BDD f, BDD d) +{ + BddCacheData *entry; + BDD res; + + if (ISONE(d) || ISCONST(f)) + return f; + if (d == f) + return BDDONE; + if (ISZERO(d)) + return BDDZERO; + + entry = BddCache_lookup(&applycache, APPLYHASH(f,d,bddop_simplify)); + + if (entry->a == f && entry->b == d && entry->c == bddop_simplify) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (LEVEL(f) == LEVEL(d)) + { + if (ISZERO(LOW(d))) + res = simplify_rec(HIGH(f), HIGH(d)); + else + if (ISZERO(HIGH(d))) + res = simplify_rec(LOW(f), LOW(d)); + else + { + PUSHREF( simplify_rec(LOW(f), LOW(d)) ); + PUSHREF( simplify_rec(HIGH(f), HIGH(d)) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + POPREF(2); + } + } + else + if (LEVEL(f) < LEVEL(d)) + { + PUSHREF( simplify_rec(LOW(f), d) ); + PUSHREF( simplify_rec(HIGH(f), d) ); + res = bdd_makenode(LEVEL(f), READREF(2), READREF(1)); + POPREF(2); + } + else /* LEVEL(d) < LEVEL(f) */ + { + PUSHREF( apply_rec(LOW(d), HIGH(d)) ); /* Exist quant */ + res = simplify_rec(f, READREF(1)); + POPREF(1); + } + + entry->a = f; + entry->b = d; + entry->c = bddop_simplify; + entry->r.res = res; + + return res; +} + + +/*=== QUANTIFICATION ===================================================*/ + +/* +NAME {* bdd\_exist *} +SECTION {* operator *} +SHORT {* existential quantification of variables *} +PROTO {* BDD bdd_exist(BDD r, BDD var) *} +DESCR {* Removes all occurences in {\tt r} of variables in the set + {\tt var} by existential quantification. *} +ALSO {* bdd\_forall, bdd\_unique, bdd\_makeset *} +RETURN {* The quantified BDD. *} +*/ +BDD bdd_exist(BDD r, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (var < 2) /* Empty set */ + return r; + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + quantid = (var << 3) | CACHEID_EXIST; /* FIXME: range */ + applyop = bddop_or; + + if (!firstReorder) + bdd_disable_reorder(); + res = quant_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +/* +NAME {* bdd\_forall *} +SECTION {* operator *} +SHORT {* universal quantification of variables *} +PROTO {* BDD bdd_forall(BDD r, BDD var) *} +DESCR {* Removes all occurences in {\tt r} of variables in the set + {\tt var} by universal quantification. *} +ALSO {* bdd\_exist, bdd\_unique, bdd\_makeset *} +RETURN {* The quantified BDD. *} +*/ +BDD bdd_forall(BDD r, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (var < 2) /* Empty set */ + return r; + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + quantid = (var << 3) | CACHEID_FORALL; + applyop = bddop_and; + + if (!firstReorder) + bdd_disable_reorder(); + res = quant_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +/* +NAME {* bdd\_unique *} +SECTION {* operator *} +SHORT {* unique quantification of variables *} +PROTO {* BDD bdd_unique(BDD r, BDD var) *} +DESCR {* Removes all occurences in {\tt r} of variables in the set + {\tt var} by unique quantification. This type of quantification + uses a XOR operator instead of an OR operator as in the + existential quantification, and an AND operator as in the + universal quantification. *} +ALSO {* bdd\_exist, bdd\_forall, bdd\_makeset *} +RETURN {* The quantified BDD. *} +*/ +BDD bdd_unique(BDD r, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (var < 2) /* Empty set */ + return r; + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + quantid = (var << 3) | CACHEID_UNIQUE; + applyop = bddop_xor; + + if (!firstReorder) + bdd_disable_reorder(); + res = quant_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static int quant_rec(int r) +{ + BddCacheData *entry; + int res; + + if (r < 2 || LEVEL(r) > quantlast) + return r; + + entry = BddCache_lookup(&quantcache, QUANTHASH(r)); + if (entry->a == r && entry->c == quantid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + PUSHREF( quant_rec(LOW(r)) ); + PUSHREF( quant_rec(HIGH(r)) ); + + if (INVARSET(LEVEL(r))) + res = apply_rec(READREF(2), READREF(1)); + else + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + + POPREF(2); + + entry->a = r; + entry->c = quantid; + entry->r.res = res; + + return res; +} + +/* +NAME {* bdd\_project *} +SECTION {* operator *} +SHORT {* projection by quantification of variables *} +PROTO {* BDD bdd_project(BDD r, BDD var) *} +DESCR {* Removes all occurences in {\tt r} of variables in the set + {\tt var} by existential quantification of variables not + in {\tt var}. *} +ALSO {* bdd\_forall, bdd\_unique, bdd\_makeset *} +RETURN {* The quantified BDD. *} +*/ +BDD bdd_project(BDD r, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (var < 2) /* Empty set */ + return r; + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + quantid = (var << 3) | CACHEID_PROJECT; + applyop = bddop_or; + + if (!firstReorder) + bdd_disable_reorder(); + res = project_rec(r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + +static int project_rec(int r) +{ + BddCacheData *entry; + int res; + + if (r < 2) + return r; + if (LEVEL(r) > quantlast) + return BDDONE; + + entry = BddCache_lookup(&quantcache, QUANTHASH(r)); + if (entry->a == r && entry->c == quantid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + PUSHREF( project_rec(LOW(r)) ); + PUSHREF( project_rec(HIGH(r)) ); + + if (INVARSET(LEVEL(r))) + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + else + res = apply_rec(READREF(2), READREF(1)); + + POPREF(2); + + entry->a = r; + entry->c = quantid; + entry->r.res = res; + + return res; +} + + +/*=== APPLY & QUANTIFY =================================================*/ + +/* +NAME {* bdd\_appex *} +SECTION {* operator *} +SHORT {* apply operation and existential quantification *} +PROTO {* BDD bdd_appex(BDD left, BDD right, int opr, BDD var) *} +DESCR {* Applies the binary operator {\tt opr} to the arguments + {\tt left} and {\tt right} and then performs an existential + quantification of the variables from the variable set + {\tt var}. This is done in a bottom up manner such that both the + apply and quantification is done on the lower nodes before + stepping up to the higher nodes. This makes the {\tt bdd\_appex} + function much more efficient than an apply operation followed + by a quantification. If the operator is a conjunction then this + is similar to the relational product of the two BDDs. + \index{relational product} *} +ALSO {* bdd\_appall, bdd\_appuni, bdd\_apply, bdd\_exist, bdd\_forall, bdd\_unique, bdd\_makeset *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_appex(BDD l, BDD r, int opr, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(l, bddfalse); + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (opr<0 || opr>bddop_invimp) + { + bdd_error(BDD_OP); + return bddfalse; + } + + if (var < 2) /* Empty set */ + return bdd_apply(l,r,opr); + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + applyop = bddop_or; + appexop = opr; + appexid = (var << 5) | (appexop << 1); /* FIXME: range! */ + quantid = (appexid << 3) | CACHEID_APPEX; + + if (!firstReorder) + bdd_disable_reorder(); + res = appquant_rec(l, r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +/* +NAME {* bdd\_appall *} +SECTION {* operator *} +SHORT {* apply operation and universal quantification *} +PROTO {* BDD bdd_appall(BDD left, BDD right, int opr, BDD var) *} +DESCR {* Applies the binary operator {\tt opr} to the arguments + {\tt left} and {\tt right} and then performs an universal + quantification of the variables from the variable set + {\tt var}. This is done in a bottom up manner such that both the + apply and quantification is done on the lower nodes before + stepping up to the higher nodes. This makes the {\tt bdd\_appall} + function much more efficient than an apply operation followed + by a quantification. *} +ALSO {* bdd\_appex, bdd\_appuni, bdd\_apply, bdd\_exist, bdd\_forall, bdd\_unique, bdd\_makeset *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_appall(BDD l, BDD r, int opr, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(l, bddfalse); + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (opr<0 || opr>bddop_invimp) + { + bdd_error(BDD_OP); + return bddfalse; + } + + if (var < 2) /* Empty set */ + return bdd_apply(l,r,opr); + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + applyop = bddop_and; + appexop = opr; + appexid = (var << 5) | (appexop << 1) | 1; /* FIXME: range! */ + quantid = (appexid << 3) | CACHEID_APPAL; + + if (!firstReorder) + bdd_disable_reorder(); + res = appquant_rec(l, r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +/* +NAME {* bdd\_appuni *} +SECTION {* operator *} +SHORT {* apply operation and unique quantification *} +PROTO {* BDD bdd_appuni(BDD left, BDD right, int opr, BDD var) *} +DESCR {* Applies the binary operator {\tt opr} to the arguments + {\tt left} and {\tt right} and then performs a unique + quantification of the variables from the variable set + {\tt var}. This is done in a bottom up manner such that both the + apply and quantification is done on the lower nodes before + stepping up to the higher nodes. This makes the {\tt bdd\_appuni} + function much more efficient than an apply operation followed + by a quantification. *} +ALSO {* bdd\_appex, bdd\_appall, bdd\_apply, bdd\_exist, bdd\_unique, bdd\_forall, bdd\_makeset *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_appuni(BDD l, BDD r, int opr, BDD var) +{ + BDD res; + firstReorder = 1; + + CHECKa(l, bddfalse); + CHECKa(r, bddfalse); + CHECKa(var, bddfalse); + + if (opr<0 || opr>bddop_invimp) + { + bdd_error(BDD_OP); + return bddfalse; + } + + if (var < 2) /* Empty set */ + return bdd_apply(l,r,opr); + + again: + if (setjmp(bddexception) == 0) + { + if (varset2vartable(var) < 0) + return bddfalse; + + INITREF; + applyop = bddop_xor; + appexop = opr; + appexid = (var << 5) | (appexop << 1) | 1; /* FIXME: range! */ + quantid = (appexid << 3) | CACHEID_APPUN; + + if (!firstReorder) + bdd_disable_reorder(); + res = appquant_rec(l, r); + if (!firstReorder) + bdd_enable_reorder(); + } + else + { + bdd_checkreorder(); + + if (firstReorder-- == 1) + goto again; + res = BDDZERO; /* avoid warning about res being uninitialized */ + } + + checkresize(); + return res; +} + + +static int appquant_rec(int l, int r) +{ + BddCacheData *entry; + int res; + + switch (appexop) + { + case bddop_and: + if (l == 0 || r == 0) + return 0; + if (l == r) + return quant_rec(l); + if (l == 1) + return quant_rec(r); + if (r == 1) + return quant_rec(l); + break; + case bddop_or: + if (l == 1 || r == 1) + return 1; + if (l == r) + return quant_rec(l); + if (l == 0) + return quant_rec(r); + if (r == 0) + return quant_rec(l); + break; + case bddop_xor: + if (l == r) + return 0; + if (l == 0) + return quant_rec(r); + if (r == 0) + return quant_rec(l); + break; + case bddop_nand: + if (l == 0 || r == 0) + return 1; + break; + case bddop_nor: + if (l == 1 || r == 1) + return 0; + break; + } + + if (ISCONST(l) && ISCONST(r)) + res = oprres[appexop][(l<<1) | r]; + else + if (LEVEL(l) > quantlast && LEVEL(r) > quantlast) + { + int oldop = applyop; + applyop = appexop; + res = apply_rec(l,r); + applyop = oldop; + } + else + { + entry = BddCache_lookup(&appexcache, APPEXHASH(l,r,appexop)); + if (entry->a == l && entry->b == r && entry->c == appexid) + { +#ifdef CACHESTATS + bddcachestats.opHit++; +#endif + return entry->r.res; + } +#ifdef CACHESTATS + bddcachestats.opMiss++; +#endif + + if (LEVEL(l) == LEVEL(r)) + { + PUSHREF( appquant_rec(LOW(l), LOW(r)) ); + PUSHREF( appquant_rec(HIGH(l), HIGH(r)) ); + if (INVARSET(LEVEL(l))) + res = apply_rec(READREF(2), READREF(1)); + else + res = bdd_makenode(LEVEL(l), READREF(2), READREF(1)); + } + else + if (LEVEL(l) < LEVEL(r)) + { + PUSHREF( appquant_rec(LOW(l), r) ); + PUSHREF( appquant_rec(HIGH(l), r) ); + if (INVARSET(LEVEL(l))) + res = apply_rec(READREF(2), READREF(1)); + else + res = bdd_makenode(LEVEL(l), READREF(2), READREF(1)); + } + else + { + PUSHREF( appquant_rec(l, LOW(r)) ); + PUSHREF( appquant_rec(l, HIGH(r)) ); + if (INVARSET(LEVEL(r))) + res = apply_rec(READREF(2), READREF(1)); + else + res = bdd_makenode(LEVEL(r), READREF(2), READREF(1)); + } + + POPREF(2); + + entry->a = l; + entry->b = r; + entry->c = appexid; + entry->r.res = res; + } + + return res; +} + + +/************************************************************************* + Informational functions +*************************************************************************/ + +/*=== SUPPORT ==========================================================*/ + +/* +NAME {* bdd\_support *} +SECTION {* info *} +SHORT {* returns the variable support of a BDD *} +PROTO {* BDD bdd_support(BDD r) *} +DESCR {* Finds all the variables that {\tt r} depends on. That is + the support of {\tt r}. *} +ALSO {* bdd\_makeset *} +RETURN {* A BDD variable set. *} +*/ +BDD bdd_support(BDD r) +{ + static int supportSize = 0; + int n; + int res=1; + + CHECKa(r, bddfalse); + + if (r < 2) + return bddfalse; + + /* On-demand allocation of support set */ + if (supportSet == NULL || supportSize < bddvarnum) + { + if ((supportSet=(int*)malloc(bddvarnum*sizeof(int))) == NULL) + { + bdd_error(BDD_MEMORY); + return bddfalse; + } + memset(supportSet, 0, bddvarnum*sizeof(int)); + supportSize = bddvarnum; + supportID = 0; + } + + /* Update global variables used to speed up bdd_support() + * - instead of always memsetting support to zero, we use + * a change counter. + * - and instead of reading the whole array afterwards, we just + * look from 'min' to 'max' used BDD variables. + */ + if (supportID == 0x0FFFFFFF) + { + /* We probably don't get here -- but let's just be sure */ + memset(supportSet, 0, bddvarnum*sizeof(int)); + supportID = 0; + } + ++supportID; + supportMin = LEVEL(r); + supportMax = supportMin; + + support_rec(r, supportSet); + bdd_unmark(r); + + bdd_disable_reorder(); + + for (n=supportMax ; n>=supportMin ; --n) + if (supportSet[n] == supportID) + { + register BDD tmp; + bdd_addref(res); + tmp = bdd_makenode(n, 0, res); + bdd_delref(res); + res = tmp; + } + + bdd_enable_reorder(); + + return res; +} + + +static void support_rec(int r, int* support) +{ + BddNode *node; + + if (r < 2) + return; + + node = &bddnodes[r]; + if (LEVELp(node) & MARKON || LOWp(node) == -1) + return; + + support[LEVELp(node)] = supportID; + + if (LEVELp(node) > supportMax) + supportMax = LEVELp(node); + + LEVELp(node) |= MARKON; + + support_rec(LOWp(node), support); + support_rec(HIGHp(node), support); +} + + +/*=== ONE SATISFYING VARIABLE ASSIGNMENT ===============================*/ + +/* +NAME {* bdd\_satone *} +SECTION {* operator *} +SHORT {* finds one satisfying variable assignment *} +PROTO {* BDD bdd_satone(BDD r) *} +DESCR {* Finds a BDD with at most one variable at each level. This BDD + implies {\tt r} and is not false unless {\tt r} is + false. *} +ALSO {* bdd\_allsat bdd\_satoneset, bdd\_fullsatone, bdd\_satcount, bdd\_satcountln *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_satone(BDD r) +{ + BDD res; + + CHECKa(r, bddfalse); + if (r < 2) + return r; + + bdd_disable_reorder(); + + INITREF; + res = satone_rec(r); + + bdd_enable_reorder(); + + checkresize(); + return res; +} + + +static BDD satone_rec(BDD r) +{ + if (ISCONST(r)) + return r; + + if (ISZERO(LOW(r))) + { + BDD res = satone_rec(HIGH(r)); + return PUSHREF( bdd_makenode(LEVEL(r), BDDZERO, res) ); + } + else + { + BDD res = satone_rec(LOW(r)); + return PUSHREF( bdd_makenode(LEVEL(r), res, BDDZERO) ); + } +} + + +/* +NAME {* bdd\_satoneset *} +SECTION {* operator *} +SHORT {* finds one satisfying variable assignment *} +PROTO {* BDD bdd_satoneset(BDD r, BDD var, BDD pol) *} +DESCR {* Finds a minterm in {\tt r}. The {\tt var} argument is a + variable set that defines a set of variables that {\em must} be + mentioned in the result. The polarity of these variables in + result---in case they are undefined in {\tt r}---are defined + by the {\tt pol} parameter. If {\tt pol} is the false BDD then + the variables will be in negative form, and otherwise they will + be in positive form. *} +ALSO {* bdd\_allsat bdd\_satone, bdd\_fullsatone, bdd\_satcount, bdd\_satcountln *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_satoneset(BDD r, BDD var, BDD pol) +{ + BDD res; + + CHECKa(r, bddfalse); + if (ISZERO(r)) + return r; + if (!ISCONST(pol)) + { + bdd_error(BDD_ILLBDD); + return bddfalse; + } + + bdd_disable_reorder(); + + INITREF; + satPolarity = pol; + res = satoneset_rec(r, var); + + bdd_enable_reorder(); + + checkresize(); + return res; +} + + +static BDD satoneset_rec(BDD r, BDD var) +{ + if (ISCONST(r) && ISCONST(var)) + return r; + + if (LEVEL(r) < LEVEL(var)) + { + if (ISZERO(LOW(r))) + { + BDD res = satoneset_rec(HIGH(r), var); + return PUSHREF( bdd_makenode(LEVEL(r), BDDZERO, res) ); + } + else + { + BDD res = satoneset_rec(LOW(r), var); + return PUSHREF( bdd_makenode(LEVEL(r), res, BDDZERO) ); + } + } + else if (LEVEL(var) < LEVEL(r)) + { + BDD res = satoneset_rec(r, HIGH(var)); + if (satPolarity == BDDONE) + return PUSHREF( bdd_makenode(LEVEL(var), BDDZERO, res) ); + else + return PUSHREF( bdd_makenode(LEVEL(var), res, BDDZERO) ); + } + else /* LEVEL(r) == LEVEL(var) */ + { + if (ISZERO(LOW(r))) + { + BDD res = satoneset_rec(HIGH(r), HIGH(var)); + return PUSHREF( bdd_makenode(LEVEL(r), BDDZERO, res) ); + } + else + { + BDD res = satoneset_rec(LOW(r), HIGH(var)); + return PUSHREF( bdd_makenode(LEVEL(r), res, BDDZERO) ); + } + } + +} + + +/*=== EXACTLY ONE SATISFYING VARIABLE ASSIGNMENT =======================*/ + +/* +NAME {* bdd\_fullsatone *} +SECTION {* operator *} +SHORT {* finds one satisfying variable assignment *} +PROTO {* BDD bdd_fullsatone(BDD r) *} +DESCR {* Finds a BDD with exactly one variable at all levels. This BDD + implies {\tt r} and is not false unless {\tt r} is + false. *} +ALSO {* bdd\_allsat bdd\_satone, bdd\_satoneset, bdd\_satcount, bdd\_satcountln *} +RETURN {* The result of the operation. *} +*/ +BDD bdd_fullsatone(BDD r) +{ + BDD res; + int v; + + CHECKa(r, bddfalse); + if (r == 0) + return 0; + + bdd_disable_reorder(); + + INITREF; + res = fullsatone_rec(r); + + for (v=LEVEL(r)-1 ; v>=0 ; v--) + { + res = PUSHREF( bdd_makenode(v, res, 0) ); + } + + bdd_enable_reorder(); + + checkresize(); + return res; +} + + +static int fullsatone_rec(int r) +{ + if (r < 2) + return r; + + if (LOW(r) != 0) + { + int res = fullsatone_rec(LOW(r)); + int v; + + for (v=LEVEL(LOW(r))-1 ; v>LEVEL(r) ; v--) + { + res = PUSHREF( bdd_makenode(v, res, 0) ); + } + + return PUSHREF( bdd_makenode(LEVEL(r), res, 0) ); + } + else + { + int res = fullsatone_rec(HIGH(r)); + int v; + + for (v=LEVEL(HIGH(r))-1 ; v>LEVEL(r) ; v--) + { + res = PUSHREF( bdd_makenode(v, res, 0) ); + } + + return PUSHREF( bdd_makenode(LEVEL(r), 0, res) ); + } +} + + +/*=== ALL SATISFYING VARIABLE ASSIGNMENTS ==============================*/ + +/* +NAME {* bdd\_allsat *} +SECTION {* operator *} +SHORT {* finds all satisfying variable assignments *} +PROTO {* BDD bdd_satone(BDD r, bddallsathandler handler) *} +DESCR {* Iterates through all legal variable assignments (those + that make the BDD come true) for the bdd {\tt r} and + calls the callback handler {\tt handler} for each of them. + The array passed to {\tt handler} contains one entry for + each of the globaly defined variables. Each entry is either + 0 if the variable is false, 1 if it is true, and -1 if it + is a don't care. + + The following is an example of a callback handler that + prints 'X' for don't cares, '0' for zero, and '1' for one: + \begin{verbatim} +void allsatPrintHandler(char* varset, int size) +{ + for (int v=0; v=0 ; --v) + allsatProfile[bddlevel2var[v]] = -1; + + allsatHandler = handler; + INITREF; + + allsat_rec(r); + + free(allsatProfile); +} + + +static void allsat_rec(BDD r) +{ + if (ISONE(r)) + { + allsatHandler(allsatProfile, bddvarnum); + return; + } + + if (ISZERO(r)) + return; + + if (!ISZERO(LOW(r))) + { + int v; + + allsatProfile[bddlevel2var[LEVEL(r)]] = 0; + + for (v=LEVEL(LOW(r))-1 ; v>LEVEL(r) ; --v) + { + allsatProfile[bddlevel2var[v]] = -1; + } + + allsat_rec(LOW(r)); + } + + if (!ISZERO(HIGH(r))) + { + int v; + + allsatProfile[bddlevel2var[LEVEL(r)]] = 1; + + for (v=LEVEL(HIGH(r))-1 ; v>LEVEL(r) ; --v) + { + allsatProfile[bddlevel2var[v]] = -1; + } + + allsat_rec(HIGH(r)); + } +} + + +/*=== COUNT NUMBER OF SATISFYING ASSIGNMENT ============================*/ + +/* +NAME {* bdd\_satcount *} +EXTRA {* bdd\_setcountset *} +SECTION {* info *} +SHORT {* calculates the number of satisfying variable assignments *} +PROTO {* double bdd_satcount(BDD r) +double bdd_satcountset(BDD r, BDD varset) *} +DESCR {* Calculates how many possible variable assignments there exists + such that {\tt r} is satisfied (true). All defined + variables are considered in the first version. In the + second version, only the variables in the variable + set {\tt varset} are considered. This makes the function a + {\em lot} slower. *} +ALSO {* bdd\_satone, bdd\_fullsatone, bdd\_satcountln *} +RETURN {* The number of possible assignments. *} +*/ +double bdd_satcount(BDD r) +{ + double size=1; + + CHECKa(r, 0.0); + + miscid = CACHEID_SATCOU; + size = pow(2.0, (double)LEVEL(r)); + + return size * satcount_rec(r); +} + + +double bdd_satcountset(BDD r, BDD varset) +{ + double unused = bddvarnum; + BDD n; + + if (ISCONST(varset) || ISZERO(r)) /* empty set */ + return 0.0; + + for (n=varset ; !ISCONST(n) ; n=HIGH(n)) + unused--; + + unused = bdd_satcount(r) / pow(2.0,unused); + + return unused >= 1.0 ? unused : 1.0; +} + + +static double satcount_rec(int root) +{ + BddCacheData *entry; + BddNode *node; + double size, s; + + if (root < 2) + return root; + + entry = BddCache_lookup(&misccache, SATCOUHASH(root)); + if (entry->a == root && entry->c == miscid) + return entry->r.dres; + + node = &bddnodes[root]; + size = 0; + s = 1; + + s *= pow(2.0, (float)(LEVEL(LOWp(node)) - LEVELp(node) - 1)); + size += s * satcount_rec(LOWp(node)); + + s = 1; + s *= pow(2.0, (float)(LEVEL(HIGHp(node)) - LEVELp(node) - 1)); + size += s * satcount_rec(HIGHp(node)); + + entry->a = root; + entry->c = miscid; + entry->r.dres = size; + + return size; +} + + +/* +NAME {* bdd\_satcountln *} +EXTRA {* bdd\_setcountlnset *} +SECTION {* info *} +SHORT {* calculates the log. number of satisfying variable assignments *} +PROTO {* double bdd_satcountln(BDD r) +double bdd_satcountlnset(BDD r, BDD varset)*} +DESCR {* Calculates how many possible variable assignments there + exists such that {\tt r} is satisfied (true) and returns + the logarithm of this. The result is calculated in such a + manner that it is practically impossible to get an + overflow, which is very possible for {\tt bdd\_satcount} if + the number of defined variables is too large. All defined + variables are considered in the first version. In the + second version, only the variables in the variable + set {\tt varset} are considered. This makes the function + a {\em lot} slower! *} +ALSO {* bdd\_satone, bdd\_fullsatone, bdd\_satcount *} +RETURN {* The logarithm of the number of possible assignments. *} */ +double bdd_satcountln(BDD r) +{ + double size; + + CHECKa(r, 0.0); + + miscid = CACHEID_SATCOULN; + size = satcountln_rec(r); + + if (size >= 0.0) + size += LEVEL(r); + + return size; +} + + +double bdd_satcountlnset(BDD r, BDD varset) +{ + double unused = bddvarnum; + BDD n; + + if (ISCONST(varset)) /* empty set */ + return 0.0; + + for (n=varset ; !ISCONST(n) ; n=HIGH(n)) + unused--; + + unused = bdd_satcountln(r) - unused; + + return unused >= 0.0 ? unused : 0.0; +} + + +static double satcountln_rec(int root) +{ + BddCacheData *entry; + BddNode *node; + double size, s1,s2; + + if (root == 0) + return -1.0; + if (root == 1) + return 0.0; + + entry = BddCache_lookup(&misccache, SATCOUHASH(root)); + if (entry->a == root && entry->c == miscid) + return entry->r.dres; + + node = &bddnodes[root]; + + s1 = satcountln_rec(LOWp(node)); + if (s1 >= 0.0) + s1 += LEVEL(LOWp(node)) - LEVELp(node) - 1; + + s2 = satcountln_rec(HIGHp(node)); + if (s2 >= 0.0) + s2 += LEVEL(HIGHp(node)) - LEVELp(node) - 1; + + if (s1 < 0.0) + size = s2; + else if (s2 < 0.0) + size = s1; + else if (s1 < s2) + size = s2 + log1p(pow(2.0,s1-s2)) / M_LN2; + else + size = s1 + log1p(pow(2.0,s2-s1)) / M_LN2; + + entry->a = root; + entry->c = miscid; + entry->r.dres = size; + + return size; +} + + +/*=== COUNT NUMBER OF ALLOCATED NODES ==================================*/ + +/* +NAME {* bdd\_nodecount *} +SECTION {* info *} +SHORT {* counts the number of nodes used for a BDD *} +PROTO {* int bdd_nodecount(BDD r) *} +DESCR {* Traverses the BDD and counts all distinct nodes that are used + for the BDD. *} +RETURN {* The number of nodes. *} +ALSO {* bdd\_pathcount, bdd\_satcount, bdd\_anodecount *} +*/ +int bdd_nodecount(BDD r) +{ + int num=0; + + CHECK(r); + + bdd_markcount(r, &num); + bdd_unmark(r); + + return num; +} + + +/* +NAME {* bdd\_anodecount *} +SECTION {* info *} +SHORT {* counts the number of shared nodes in an array of BDDs *} +PROTO {* int bdd_anodecount(BDD *r, int num) *} +DESCR {* Traverses all of the BDDs in {\tt r} and counts all distinct nodes + that are used in the BDDs--if a node is used in more than one + BDD then it only counts once. The {\tt num} parameter holds the + size of the array. *} +RETURN {* The number of nodes *} +ALSO {* bdd\_nodecount *} +*/ +int bdd_anodecount(BDD *r, int num) +{ + int n; + int cou=0; + + for (n=0 ; na == r && entry->c == miscid) + return entry->r.dres; + + size = bdd_pathcount_rec(LOW(r)) + bdd_pathcount_rec(HIGH(r)); + + entry->a = r; + entry->c = miscid; + entry->r.dres = size; + + return size; +} + + +/************************************************************************* + Other internal functions +*************************************************************************/ + +static int varset2vartable(BDD r) +{ + BDD n; + + if (r < 2) + return bdd_error(BDD_VARSET); + + quantvarsetID++; + + if (quantvarsetID == INT_MAX) + { + memset(quantvarset, 0, sizeof(int)*bddvarnum); + quantvarsetID = 1; + } + + for (n=r ; n > 1 ; n=HIGH(n)) + { + quantvarset[LEVEL(n)] = quantvarsetID; + quantlast = LEVEL(n); + } + + return 0; +} + + +static int varset2svartable(BDD r) +{ + BDD n; + + if (r < 2) + return bdd_error(BDD_VARSET); + + quantvarsetID++; + + if (quantvarsetID == INT_MAX/2) + { + memset(quantvarset, 0, sizeof(int)*bddvarnum); + quantvarsetID = 1; + } + + for (n=r ; !ISCONST(n) ; ) + { + if (ISZERO(LOW(n))) + { + quantvarset[LEVEL(n)] = quantvarsetID; + n = HIGH(n); + } + else + { + quantvarset[LEVEL(n)] = -quantvarsetID; + n = LOW(n); + } + quantlast = LEVEL(n); + } + + return 0; +} + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/bddtest.cxx b/sdk/buddy-2.4/src/bddtest.cxx new file mode 100644 index 0000000..e2ab42b --- /dev/null +++ b/sdk/buddy-2.4/src/bddtest.cxx @@ -0,0 +1,110 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +#include +#include "bdd.h" +#include "bvec.h" + +using namespace std; + + +#define ERROR(msg) fail(msg, __FILE__, __LINE__) + +static void fail(const string msg, const char* file, int lineNum) +{ + cout << "Error in " << file << "(" << lineNum << "): " << msg << endl; + exit(1); +} + + +static void testSupport(void) +{ + bdd even = bdd_ithvar(0) | bdd_ithvar(2) | bdd_ithvar(4); + bdd odd = bdd_ithvar(1) | bdd_ithvar(3) | bdd_ithvar(5); + + cout << "Testing support\n"; + + bdd s1 = bdd_support(even); + bdd s2 = bdd_support(odd); + + if (s1 != (bdd_ithvar(0) & bdd_ithvar(2) & bdd_ithvar(4))) + ERROR("Support of 'even' failed\n"); + if (s2 != (bdd_ithvar(1) & bdd_ithvar(3) & bdd_ithvar(5))) + ERROR("Support of 'odd' failed\n"); + + /* Try many time in order check that the internal support ID + * is set correctly */ + for (int n=0 ; n<500 ; ++n) + { + s1 = bdd_support(even); + s2 = bdd_support(odd); + + if (s1 != (bdd_ithvar(0) & bdd_ithvar(2) & bdd_ithvar(4))) + ERROR("Support of 'even' failed"); + if (s2 != (bdd_ithvar(1) & bdd_ithvar(3) & bdd_ithvar(5))) + ERROR("Support of 'odd' failed"); + } +} + + +void testBvecIte() +{ + cout << "Testing ITE for vector\n"; + + bdd a = bdd_ithvar(0); + bvec b = bvec_var(3, 1, 2); + bvec c = bvec_var(3, 2, 2); + + bvec res = bvec_ite(a,b,c); + + bdd r0 = bdd_ite( bdd_ithvar(0), bdd_ithvar(1), bdd_ithvar(2) ); + bdd r1 = bdd_ite( bdd_ithvar(0), bdd_ithvar(3), bdd_ithvar(4) ); + bdd r2 = bdd_ite( bdd_ithvar(0), bdd_ithvar(5), bdd_ithvar(6) ); + + if (res[0] != r0) + ERROR("Bit 0 failed."); + if (res[1] != r1) + ERROR("Bit 1 failed."); + if (res[2] != r2) + ERROR("Bit 2 failed."); +} + + +int main(int ac, char** av) +{ + bdd_init(1000,1000); + + bdd_setvarnum(10); + + testSupport(); + testBvecIte(); + + bdd_done(); + return 0; +} diff --git a/sdk/buddy-2.4/src/bddtree.h b/sdk/buddy-2.4/src/bddtree.h new file mode 100644 index 0000000..310c07d --- /dev/null +++ b/sdk/buddy-2.4/src/bddtree.h @@ -0,0 +1,60 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bddtree.h,v 1.1.1.1 2004/06/25 13:22:26 haimcohen Exp $ + FILE: tree.h + DESCR: Trees for BDD variables + AUTH: Jorn Lind + DATE: (C) march 1998 +*************************************************************************/ + +#ifndef _TREE_H +#define _TREE_H + +typedef struct s_BddTree +{ + int first, last; /* First and last variable in this block */ + int pos; /* Sifting position */ + int *seq; /* Sequence of first...last in the current order */ + char fixed; /* Are the sub-blocks fixed or may they be reordered */ + int id; /* A sequential id number given by addblock */ + struct s_BddTree *next, *prev; + struct s_BddTree *nextlevel; +} BddTree; + +BddTree *bddtree_new(int); +void bddtree_del(BddTree *); +BddTree *bddtree_addrange(BddTree *, int, int, int, int); +void bddtree_print(FILE *, BddTree *, int); + +#endif /* _TREE_H */ + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/buddy-2.4-stamp/buddy-2.4-done b/sdk/buddy-2.4/src/buddy-2.4-stamp/buddy-2.4-done new file mode 100644 index 0000000..e69de29 diff --git a/sdk/buddy-2.4/src/bvec.c b/sdk/buddy-2.4/src/bvec.c new file mode 100644 index 0000000..c2eed95 --- /dev/null +++ b/sdk/buddy-2.4/src/bvec.c @@ -0,0 +1,1355 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/bvec.c,v 1.1.1.1 2004/06/25 13:22:34 haimcohen Exp $ + FILE: bvec.c + DESCR: Boolean vector arithmetics using BDDs + AUTH: Jorn Lind + DATE: (C) may 1999 +*************************************************************************/ +#include +#include "kernel.h" +#include "bvec.h" + +#define DEFAULT(v) { v.bitnum=0; v.bitvec=NULL; } + +/************************************************************************* +*************************************************************************/ + +static bvec bvec_build(int bitnum, int isTrue) +{ + bvec vec; + int n; + + vec.bitvec = NEW(BDD,bitnum); + vec.bitnum = bitnum; + if (!vec.bitvec) + { + bdd_error(BDD_MEMORY); + vec.bitnum = 0; + return vec; + } + + for (n=0 ; n 0) + { + val >>= 1; + bitnum++; + } + + return bitnum; +} +#endif + +/* +NAME {* bvec\_copy *} +SECTION {* bvec *} +SHORT {* create a copy of a bvec *} +PROTO {* bvec bvec_copy(bvec src) *} +DESCR {* Returns a copy of {\tt src}. The result is reference counted. *} +ALSO {* bvec\_con *} +*/ +bvec bvec_copy(bvec src) +{ + bvec dst; + int n; + + if (src.bitnum == 0) + { + DEFAULT(dst); + return dst; + } + + dst = bvec_build(src.bitnum,0); + + for (n=0 ; n> 1; + } + + return v; +} + + +/* +NAME {* bvec\_var *} +SECTION {* bvec *} +SHORT {* build a boolean vector with BDD variables *} +PROTO {* bvec bvec_var(int bitnum, int offset, int step) *} +DESCR {* Builds a boolean vector with the BDD variables $v_1, \ldots, + v_n$ as the elements. Each variable will be the the variabled + numbered {\tt offset + N*step} where {\tt N} ranges from 0 to + {\tt bitnum}-1.*} +RETURN {* The boolean vector (which is already reference counted) *} +ALSO {* bvec\_true, bvec\_false, bvec\_con *} +*/ +bvec bvec_var(int bitnum, int offset, int step) +{ + bvec v; + int n; + + v = bvec_build(bitnum,0); + + for (n=0 ; n=0 ; n--) + if (ISONE(e.bitvec[n])) + val = (val << 1) | 1; + else if (ISZERO(e.bitvec[n])) + val = val << 1; + else + return 0; + + return val; +} + + +/*======================================================================*/ + +/* +NAME {* bvec\_free *} +SECTION {* bvec *} +SHORT {* frees all memory used by a boolean vector *} +PROTO {* void bvec_free(bvec v) *} +DESCR {* Use this function to release any unused boolean vectors. The + decrease of the reference counts on the BDDs in {\tt v} is done + by {\tt bvec\_free}. *} +*/ +void bvec_free(bvec v) +{ + bvec_delref(v); + free(v.bitvec); +} + + +/* +NAME {* bvec\_addref *} +SECTION {* bvec *} +SHORT {* increase reference count of a boolean vector *} +PROTO {* bvec bvec_addref(bvec v) *} +DESCR {* Use this function to increase the reference count of all BDDs + in a {\tt v}. Please note that all boolean vectors returned + from BuDDy are reference counted from the beginning. *} +RETURN {* The boolean vector {\tt v} *} +ALSO {* bvec\_delref *} +*/ +bvec bvec_addref(bvec v) +{ + int n; + + for (n=0 ; n>1); + + if (c & 0x1) + { + res = bvec_add(e, rest); + bvec_free(rest); + } + else + res = rest; + + bvec_free(next); + + return res; +} + + +/* +NAME {* bvec\_mul *} +SECTION {* bvec *} +SHORT {* builds a boolean vector for multiplication *} +PROTO {* bvec bvec_mul(bvec l, bvec r) *} +DESCR {* Builds a boolean vector representing the multiplication + of {\tt l} and {\tt r}. *} +RETURN {* The result of the multiplication (which is already reference counted) *} +ALSO {* bvec\_mulfixed, bvec\_div, bvec\_add, bvec\_shl *} +*/ +bvec bvec_mul(bvec left, bvec right) +{ + int n; + int bitnum = left.bitnum + right.bitnum; + bvec res; + bvec leftshifttmp; + bvec leftshift; + + if (left.bitnum == 0 || right.bitnum == 0) + { + DEFAULT(res); + return res; + } + + res = bvec_false(bitnum); + leftshifttmp = bvec_copy(left); + leftshift = bvec_coerce(bitnum, leftshifttmp); + + /*bvec_delref(leftshifttmp);*/ + bvec_free(leftshifttmp); + + for (n=0 ; n=1 ; m--) + leftshift.bitvec[m] = leftshift.bitvec[m-1]; + leftshift.bitvec[0] = bddfalse; + + /*bvec_delref(added);*/ + bvec_free(added); + } + + /*bvec_delref(leftshift);*/ + bvec_free(leftshift); + + return res; +} + +static void bvec_div_rec(bvec divisor, bvec *remainder, bvec *result, int step) +{ + int n; + BDD isSmaller = bdd_addref( bvec_lte(divisor, *remainder) ); + bvec newResult = bvec_shlfixed( *result, 1, isSmaller ); + bvec zero = bvec_build(divisor.bitnum, bddfalse); + bvec newRemainder, tmp, sub = bvec_build(divisor.bitnum, bddfalse); + + for (n=0 ; nbitvec[divisor.bitnum-1]); + + if (step > 1) + bvec_div_rec( divisor, &newRemainder, &newResult, step-1 ); + + bvec_free(tmp); + bvec_free(sub); + bvec_free(zero); + bdd_delref(isSmaller); + + bvec_free(*remainder); + bvec_free(*result); + *result = newResult; + *remainder = newRemainder; +} + + +/* +NAME {* bvec\_divfixed *} +SECTION {* bvec *} +SHORT {* builds a boolean vector for division by a constant *} +PROTO {* int bvec_div(bvec e, int c, bvec *res, bvec *rem) *} +DESCR {* Builds a new boolean vector representing the integer division + of {\tt e} with {\tt c}. The result of the division will be stored + in {\tt res} and the remainder of the division will be stored in + {\tt rem}. Both vectors should be initialized as the function + will try to release the nodes used by them. If an error occurs then + the nodes will {\em not} be freed. *} +RETURN {* Zero on success or a negative error code on error. *} +ALSO {* bvec\_div, bvec\_mul, bvec\_add, bvec\_shl *} +*/ +int bvec_divfixed(bvec e, int c, bvec *res, bvec *rem) +{ + if (c > 0) + { + bvec divisor = bvec_con(e.bitnum, c); + bvec tmp = bvec_build(e.bitnum, 0); + bvec tmpremainder = bvec_shlfixed(tmp, 1, e.bitvec[e.bitnum-1]); + bvec result = bvec_shlfixed(e, 1, bddfalse); + bvec remainder; + + bvec_div_rec(divisor, &tmpremainder, &result, divisor.bitnum); + remainder = bvec_shrfixed(tmpremainder, 1, bddfalse); + + bvec_free(tmp); + bvec_free(tmpremainder); + bvec_free(divisor); + + *res = result; + *rem = remainder; + + return 0; + } + + return bdd_error(BVEC_DIVZERO); +} + +#if 0 +void p(bvec x) +{ + int n; + for (n=0 ; n 0) + res.bitvec[right.bitnum-n] = divLteRem; + + /* Shift 'div' one bit right */ + bdd_delref(div.bitvec[0]); + for (m=0 ; m= 0) + tmp1 = bdd_addref( bdd_and(rEquN, l.bitvec[m-n]) ); + else + tmp1 = bdd_addref( bdd_and(rEquN, c) ); + tmp2 = bdd_addref( bdd_or(res.bitvec[m], tmp1) ); + bdd_delref(tmp1); + + bdd_delref(res.bitvec[m]); + res.bitvec[m] = tmp2; + } + + bdd_delref(rEquN); + /*bvec_delref(val);*/ + bvec_free(val); + } + + /* At last make sure 'c' is shiftet in for r-values > l-bitnum */ + val = bvec_con(r.bitnum, l.bitnum); + rEquN = bdd_addref( bvec_gth(r, val) ); + tmp1 = bdd_addref( bdd_and(rEquN, c) ); + + for (m=0 ; m l-bitnum */ + val = bvec_con(r.bitnum, l.bitnum); + rEquN = bdd_addref( bvec_gth(r, val) ); + tmp1 = bdd_addref( bdd_and(rEquN, c) ); + + for (m=0 ; m y$ *} +PROTO {* bdd bvec_gth(bvec l, bvec r) *} +DESCR {* Returns the BDD representing {\tt l > r} + ({\em not} reference counted). Both vectors must have the + same number of bits. *} +ALSO {* bvec\_lth, bvec\_lte, bvec\_gte, bvec\_equ, bvec\_neq *} +*/ +bdd bvec_gth(bvec l, bvec r) +{ + BDD tmp = bdd_addref( bvec_lte(l,r) ); + BDD p = bdd_not(tmp); + bdd_delref(tmp); + return p; +} + + +/* +NAME {* bvec\_gte *} +SECTION {* bvec *} +SHORT {* calculates the truth value of $x \geq y$ *} +PROTO {* bdd bvec_gte(bvec l, bvec r) *} +DESCR {* Returns the BDD representing {\tt l}$\geq${\tt r} + ({\em not} reference counted). Both vectors must have the + same number of bits. *} +ALSO {* bvec\_lth, bvec\_gth, bvec\_gth, bvec\_equ, bvec\_neq *} +*/ +bdd bvec_gte(bvec l, bvec r) +{ + BDD tmp = bdd_addref( bvec_lth(l,r) ); + BDD p = bdd_not(tmp); + bdd_delref(tmp); + return p; +} + + +/* +NAME {* bvec\_equ *} +SECTION {* bvec *} +SHORT {* calculates the truth value of $x = y$ *} +PROTO {* bdd bvec_equ(bvec l, bvec r) *} +DESCR {* Returns the BDD representing {\tt l = r} + ({\em not} reference counted). Both vectors must have the + same number of bits. *} +ALSO {* bvec\_lth, bvec\_lte, bvec\_gth, bvec\_gte, bvec\_neq *} +*/ +bdd bvec_equ(bvec l, bvec r) +{ + BDD p = bddtrue; + int n; + + if (l.bitnum == 0 || r.bitnum == 0) + return bddfalse; + + if (l.bitnum != r.bitnum) + { + bdd_error(BVEC_SIZE); + return p; + } + + for (n=0 ; n>(int a) const { return bvec_shrfixed(*this,a,bddfalse); } + bvec operator>>(const bvec &a) const { return bvec_shr(*this,a,bddfalse); } + bvec operator+(const bvec &a) const { return bvec_add(*this, a); } + bvec operator-(const bvec &a) const { return bvec_sub(*this, a); } + bvec operator*(int a) const { return bvec_mulfixed(*this, a); } + bvec operator*(const bvec a) const { return bvec_mul(*this, a); } + bdd operator<(const bvec &a) const { return bvec_lth(*this, a); } + bdd operator<=(const bvec &a) const { return bvec_lte(*this, a); } + bdd operator>(const bvec &a) const { return bvec_gth(*this, a); } + bdd operator>=(const bvec &a) const { return bvec_gte(*this, a); } + bdd operator==(const bvec &a) const { return bvec_equ(*this, a); } + bdd operator!=(const bvec &a) const { return bvec_neq(*this, a); } +}; + +std::ostream &operator<<(std::ostream &, const bvec &); + +inline bvec bvec_truepp(int bitnum) +{ return bvec_true(bitnum); } + +inline bvec bvec_falsepp(int bitnum) +{ return bvec_false(bitnum); } + +inline bvec bvec_conpp(int bitnum, int val) +{ return bvec_con(bitnum, val); } + +inline bvec bvec_varpp(int bitnum, int offset, int step) +{ return bvec_var(bitnum, offset, step); } + +inline bvec bvec_varfddpp(int var) +{ return bvec_varfdd(var); } + +inline bvec bvec_varvecpp(int bitnum, int *var) +{ return bvec_varvec(bitnum, var); } + +inline bvec bvec_coerce(int bitnum, const bvec &v) +{ return bvec_coerce(bitnum, v.roots); } + +inline int bvec_isconst(const bvec &e) +{ return bvec_isconst(e.roots); } + +inline int bvec_val(const bvec &e) +{ return bvec_val(e.roots); } + +inline bvec bvec_copy(const bvec &v) +{ return bvec_copy(v.roots); } + +inline bvec bvec_add(const bvec &left, const bvec &right) +{ return bvec_add(left.roots, right.roots); } + +inline bvec bvec_sub(const bvec &left, const bvec &right) +{ return bvec_sub(left.roots, right.roots); } + +inline bvec bvec_mulfixed(const bvec &e, int c) +{ return bvec_mulfixed(e.roots, c); } + +inline bvec bvec_mul(const bvec &left, const bvec &right) +{ return bvec_mul(left.roots, right.roots); } + +inline int bvec_divfixed(const bvec &e, int c, bvec &res, bvec &rem) +{ return bvec_divfixed(e.roots, c, &res.roots, &rem.roots); } + +inline int bvec_div(const bvec &l, const bvec &r, bvec &res, bvec &rem) +{ return bvec_div(l.roots, r.roots, &res.roots, &rem.roots); } + +inline bvec bvec_ite(const bdd& a, const bvec& b, const bvec& c) +{ return bvec_ite(a.root, b.roots, c.roots); } + +inline bvec bvec_shlfixed(const bvec &e, int pos, const bdd &c) +{ return bvec_shlfixed(e.roots, pos, c.root); } + +inline bvec bvec_shl(const bvec &left, const bvec &right, const bdd &c) +{ return bvec_shl(left.roots, right.roots, c.root); } + +inline bvec bvec_shrfixed(const bvec &e, int pos, const bdd &c) +{ return bvec_shrfixed(e.roots, pos, c.root); } + +inline bvec bvec_shr(const bvec &left, const bvec &right, const bdd &c) +{ return bvec_shr(left.roots, right.roots, c.root); } + +inline bdd bvec_lth(const bvec &left, const bvec &right) +{ return bvec_lth(left.roots, right.roots); } + +inline bdd bvec_lte(const bvec &left, const bvec &right) +{ return bvec_lte(left.roots, right.roots); } + +inline bdd bvec_gth(const bvec &left, const bvec &right) +{ return bvec_gth(left.roots, right.roots); } + +inline bdd bvec_gte(const bvec &left, const bvec &right) +{ return bvec_gte(left.roots, right.roots); } + +inline bdd bvec_equ(const bvec &left, const bvec &right) +{ return bvec_equ(left.roots, right.roots); } + +inline bdd bvec_neq(const bvec &left, const bvec &right) +{ return bvec_neq(left.roots, right.roots); } + + + /* Hack to allow for overloading */ +#define bvec_var(a,b,c) bvec_varpp(a,b,c) +#define bvec_varfdd(a) bvec_varfddpp(a) +#define bvec_varvec(a,b) bvec_varvecpp(a,b) +#define bvec_true(a) bvec_truepp(a) +#define bvec_false(a) bvec_falsepp(a) +#define bvec_con(a,b) bvec_conpp((a),(b)) + + +#endif /* CPLUSPLUS */ + +#endif /* _BVEC_H */ + +/* EOF */ diff --git a/sdk/buddy-2.4/src/cache.c b/sdk/buddy-2.4/src/cache.c new file mode 100644 index 0000000..603fecb --- /dev/null +++ b/sdk/buddy-2.4/src/cache.c @@ -0,0 +1,97 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/cache.c,v 1.1.1.1 2004/06/25 13:22:34 haimcohen Exp $ + FILE: cache.c + DESCR: Cache class for caching apply/exist etc. results in BDD package + AUTH: Jorn Lind + DATE: (C) june 1997 +*************************************************************************/ +#include +#include "kernel.h" +#include "cache.h" +#include "prime.h" + +/************************************************************************* +*************************************************************************/ + +int BddCache_init(BddCache *cache, int size) +{ + int n; + + size = bdd_prime_gte(size); + + if ((cache->table=NEW(BddCacheData,size)) == NULL) + return bdd_error(BDD_MEMORY); + + for (n=0 ; ntable[n].a = -1; + cache->tablesize = size; + + return 0; +} + + +void BddCache_done(BddCache *cache) +{ + free(cache->table); + cache->table = NULL; + cache->tablesize = 0; +} + + +int BddCache_resize(BddCache *cache, int newsize) +{ + int n; + + free(cache->table); + + newsize = bdd_prime_gte(newsize); + + if ((cache->table=NEW(BddCacheData,newsize)) == NULL) + return bdd_error(BDD_MEMORY); + + for (n=0 ; ntable[n].a = -1; + cache->tablesize = newsize; + + return 0; +} + + +void BddCache_reset(BddCache *cache) +{ + register int n; + for (n=0 ; ntablesize ; n++) + cache->table[n].a = -1; +} + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/cache.h b/sdk/buddy-2.4/src/cache.h new file mode 100644 index 0000000..9533a0f --- /dev/null +++ b/sdk/buddy-2.4/src/cache.h @@ -0,0 +1,70 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/cache.h,v 1.1.1.1 2004/06/25 13:22:34 haimcohen Exp $ + FILE: cache.h + DESCR: Cache class for caching apply/exist etc. results + AUTH: Jorn Lind + DATE: (C) june 1997 +*************************************************************************/ + +#ifndef _CACHE_H +#define _CACHE_H + +typedef struct +{ + union + { + double dres; + int res; + } r; + int a,b,c; +} BddCacheData; + + +typedef struct +{ + BddCacheData *table; + int tablesize; +} BddCache; + + +extern int BddCache_init(BddCache *, int); +extern void BddCache_done(BddCache *); +extern int BddCache_resize(BddCache *, int); +extern void BddCache_reset(BddCache *); + +#define BddCache_lookup(cache, hash) (&(cache)->table[hash % (cache)->tablesize]) + + +#endif /* _CACHE_H */ + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/cppext.cxx b/sdk/buddy-2.4/src/cppext.cxx new file mode 100644 index 0000000..d034314 --- /dev/null +++ b/sdk/buddy-2.4/src/cppext.cxx @@ -0,0 +1,624 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/cppext.cxx,v 1.1.1.1 2004/06/25 13:22:39 haimcohen Exp $ + FILE: cppext.cxx + DESCR: C++ extension of BDD package + AUTH: Jorn Lind + DATE: (C) august 1997 +*************************************************************************/ +#include +#include +#include +#include "kernel.h" +#include "bvec.h" + +using namespace std; + + /* Formatting objects for iostreams */ +#define IOFORMAT_SET 0 +#define IOFORMAT_TABLE 1 +#define IOFORMAT_DOT 2 +#define IOFORMAT_ALL 3 +#define IOFORMAT_FDDSET 4 + +int bdd_ioformat::curformat = IOFORMAT_SET; +bdd_ioformat bddset(IOFORMAT_SET); +bdd_ioformat bddtable(IOFORMAT_TABLE); +bdd_ioformat bdddot(IOFORMAT_DOT); +bdd_ioformat bddall(IOFORMAT_ALL); +bdd_ioformat fddset(IOFORMAT_FDDSET); + + /* Constant true and false extension */ +const bdd bddtruepp = bdd_true(); +const bdd bddfalsepp = bdd_false(); + + /* Internal prototypes */ +static void bdd_printset_rec(ostream&, int, int*); +static void bdd_printdot_rec(ostream&, int); +static void fdd_printset_rec(ostream &, int, int *); + + +static bddstrmhandler strmhandler_bdd; +static bddstrmhandler strmhandler_fdd; + + // Avoid calling C++ version of anodecount +#undef bdd_anodecount + +/************************************************************************* + Setup (and shutdown) +*************************************************************************/ + +#undef bdd_init + +int bdd_cpp_init(int n, int c) +{ + int ok = bdd_init(n,c); + + strmhandler_bdd = NULL; + strmhandler_fdd = NULL; + + return ok; +} + + +/************************************************************************* + BDD C++ functions +*************************************************************************/ + +bdd bdd_buildcube(int val, int width, const bdd *variables) +{ + BDD *var = NEW(BDD,width); + BDD res; + int n; + + // No need for ref.cou. since variables[n] holds the reference + for (n=0 ; n 0) + { + if (!first) + o << ", "; + first = 0; + if (strmhandler_bdd) + strmhandler_bdd(o,bddlevel2var[n]); + else + o << bddlevel2var[n]; + o << ":" << (set[n]==2 ? 1 : 0); + } + } + + o << ">"; + } + else + { + set[LEVEL(r)] = 1; + bdd_printset_rec(o, LOW(r), set); + + set[LEVEL(r)] = 2; + bdd_printset_rec(o, HIGH(r), set); + + set[LEVEL(r)] = 0; + } +} + + +static void bdd_printdot_rec(ostream& o, int r) +{ + if (ISCONST(r) || MARKED(r)) + return; + + o << r << "[label=\""; + if (strmhandler_bdd) + strmhandler_bdd(o,bddlevel2var[LEVEL(r)]); + else + o << bddlevel2var[LEVEL(r)]; + o << "\"];\n"; + o << r << " -> " << LOW(r) << "[style=dotted];\n"; + o << r << " -> " << HIGH(r) << "[style=filled];\n"; + + SETMARK(r); + + bdd_printdot_rec(o, LOW(r)); + bdd_printdot_rec(o, HIGH(r)); +} + + +static void fdd_printset_rec(ostream &o, int r, int *set) +{ + int n,m,i; + int used = 0; + int *binval; + int ok, first; + + if (r == 0) + return; + else + if (r == 1) + { + o << "<"; + first=1; + int fdvarnum = fdd_domainnum(); + + for (n=0 ; n"; + } + else + { + set[bddlevel2var[LEVEL(r)]] = 1; + fdd_printset_rec(o, LOW(r), set); + + set[bddlevel2var[LEVEL(r)]] = 2; + fdd_printset_rec(o, HIGH(r), set); + + set[bddlevel2var[LEVEL(r)]] = 0; + } +} + + +/*=[ FDD I/O functions ]================================================*/ + +/* +NAME {* fdd\_strm\_hook *} +SECTION {* fdd *} +SHORT {* Specifies a printing callback handler *} +PROTO {* bddstrmhandler fdd_strm_hook(bddstrmhandler handler) *} +DESCR {* A printing callback handler for use with FDDs is used to + convert the FDD integer identifier into something readable by the + end user. Typically the handler will print a string name + instead of the identifier. A handler could look like this: + \begin{verbatim} +void printhandler(ostream &o, int var) +{ + extern char **names; + o << names[var]; +} +\end{verbatim} + + \noindent + The handler can then be passed to BuDDy like this: + {\tt fdd\_strm\_hook(printhandler)}. + + No default handler is supplied. The argument {\tt handler} may be + NULL if no handler is needed. *} +RETURN {* The old handler *} +ALSO {* fdd\_printset, bdd\_file\_hook *} +*/ +bddstrmhandler fdd_strm_hook(bddstrmhandler handler) +{ + bddstrmhandler old = strmhandler_fdd; + strmhandler_fdd = handler; + return old; +} + + +/************************************************************************* + bvec functions +*************************************************************************/ + +bvec bvec::operator=(const bvec &src) +{ + if (&src != this) + { + bvec_free(roots); + roots = bvec_copy(src.roots); + } + return *this; +} + + +void bvec::set(int bitnum, const bdd &b) +{ + bdd_delref(roots.bitvec[bitnum]); + roots.bitvec[bitnum] = b.root; + bdd_addref(roots.bitvec[bitnum]); +} + + +/*======================================================================*/ + +bvec bvec_map1(const bvec &a, + bdd (*fun)(const bdd &)) +{ + bvec res; + int n; + + res = bvec_false(a.bitnum()); + for (n=0 ; n < a.bitnum() ; n++) + res.set(n, fun(a[n])); + + return res; +} + + +bvec bvec_map2(const bvec &a, const bvec &b, + bdd (*fun)(const bdd &, const bdd &)) +{ + bvec res; + int n; + + if (a.bitnum() != b.bitnum()) + { + bdd_error(BVEC_SIZE); + return res; + } + + res = bvec_false(a.bitnum()); + for (n=0 ; n < a.bitnum() ; n++) + res.set(n, fun(a[n], b[n])); + + return res; +} + + +bvec bvec_map3(const bvec &a, const bvec &b, const bvec &c, + bdd (*fun)(const bdd &, const bdd &, const bdd &)) +{ + bvec res; + int n; + + if (a.bitnum() != b.bitnum() || b.bitnum() != c.bitnum()) + { + bdd_error(BVEC_SIZE); + return res; + } + + res = bvec_false(a.bitnum()); + for (n=0 ; n < a.bitnum() ; n++) + res.set(n, fun(a[n], b[n], c[n]) ); + + return res; +} + + +ostream &operator<<(ostream &o, const bvec &v) +{ + for (int i=0 ; i +#include +#include "kernel.h" +#include "fdd.h" + + +static void fdd_printset_rec(FILE *, int, int *); + +/*======================================================================*/ +/* NOTE: ALL FDD operations works with LSB in top of the variable order */ +/* and in index zero of the domain tables */ +/*======================================================================*/ + +typedef struct s_Domain +{ + int realsize; /* The specified domain (0...N-1) */ + int binsize; /* The number of BDD variables representing the domain */ + int *ivar; /* Variable indeces for the variable set */ + BDD var; /* The BDD variable set */ +} Domain; + + +static void Domain_allocate(Domain*, int); +static void Domain_done(Domain*); + +static int firstbddvar; +static int fdvaralloc; /* Number of allocated domains */ +static int fdvarnum; /* Number of defined domains */ +static Domain *domain; /* Table of domain sizes */ + +static bddfilehandler filehandler; + +/************************************************************************* + Domain definition +*************************************************************************/ + +void bdd_fdd_init(void) +{ + domain = NULL; + fdvarnum = fdvaralloc = 0; + firstbddvar = 0; +} + + +void bdd_fdd_done(void) +{ + int n; + + if (domain != NULL) + { + for (n=0 ; n fdvaralloc) + { + fdvaralloc += (num > fdvaralloc) ? num : fdvaralloc; + + domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); + if (domain == NULL) + return bdd_error(BDD_MEMORY); + } + } + + /* Create bdd variable tables */ + for (n=0 ; n bddvarnum) + bdd_setvarnum(firstbddvar + extravars); + + /* Set correct variable sequence (interleaved) */ + for (bn=0,more=1 ; more ; bn++) + { + more = 0; + + for (n=0 ; n= fdvarnum || v2 < 0 || v2 >= fdvarnum) + return bdd_error(BDD_VAR); + + if (fdvarnum + 1 > fdvaralloc) + { + fdvaralloc += fdvaralloc; + + domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); + if (domain == NULL) + return bdd_error(BDD_MEMORY); + } + + d = &domain[fdvarnum]; + d->realsize = domain[v1].realsize * domain[v2].realsize; + d->binsize = domain[v1].binsize + domain[v2].binsize; + d->ivar = (int *)malloc(sizeof(int)*d->binsize); + + for (n=0 ; nivar[n] = domain[v1].ivar[n]; + for (n=0 ; nivar[domain[v1].binsize+n] = domain[v2].ivar[n]; + + d->var = bdd_makeset(d->ivar, d->binsize); + bdd_addref(d->var); + + return fdvarnum++; +} + + +/* +NAME {* fdd\_clearall *} +SECTION {* fdd *} +SHORT {* clear all allocated FDD blocks *} +PROTO {* void fdd_clearall(void) *} +DESCR {* Removes all defined finite domain blocks defined by + {\tt fdd\_extdomain()} and {\tt fdd\_overlapdomain()} *} +*/ +void fdd_clearall(void) +{ + bdd_fdd_done(); + bdd_fdd_init(); +} + + +/************************************************************************* + FDD helpers +*************************************************************************/ + +/* +NAME {* fdd\_domainnum *} +SECTION {* fdd *} +SHORT {* number of defined finite domain blocks *} +PROTO {* int fdd_domainnum(void) *} +DESCR {* Returns the number of finite domain blocks define by calls to + {\tt bdd\_extdomain}. *} +RETURN {* The number of defined finite domain blocks + or a negative error code *} +ALSO {* fdd\_domainsize, fdd\_extdomain *} +*/ +int fdd_domainnum(void) +{ + if (!bddrunning) + return bdd_error(BDD_RUNNING); + + return fdvarnum; +} + + +/* +NAME {* fdd\_domainsize *} +SECTION {* fdd *} +SHORT {* real size of a finite domain block *} +PROTO {* int fdd_domainsize(int var) *} +DESCR {* Returns the size of the domain for the finite domain + block {\tt var}. *} +RETURN {* The size or a negative error code *} +ALSO {* fdd\_domainnum *} +*/ +int fdd_domainsize(int v) +{ + if (!bddrunning) + return bdd_error(BDD_RUNNING); + + if (v < 0 || v >= fdvarnum) + return bdd_error(BDD_VAR); + return domain[v].realsize; +} + + +/* +NAME {* fdd\_varnum *} +SECTION {* fdd *} +SHORT {* binary size of a finite domain block *} +PROTO {* int fdd_varnum(int var) *} +DESCR {* Returns the number of BDD variables used for the finite domain + block {\tt var}. *} +RETURN {* The number of variables or a negative error code *} +ALSO {* fdd\_vars *} +*/ +int fdd_varnum(int v) +{ + if (!bddrunning) + return bdd_error(BDD_RUNNING); + + if (v >= fdvarnum || v < 0) + return bdd_error(BDD_VAR); + return domain[v].binsize; +} + + +/* +NAME {* fdd\_vars *} +SECTION {* fdd *} +SHORT {* all BDD variables associated with a finite domain block *} +PROTO {* int *fdd_vars(int var) *} +DESCR {* Returns an integer array containing the BDD variables used to + define the finite domain block {\tt var}. The size of the array + is the number of variables used to define the finite domain block. + The array will have the Least Significant Bit at pos 0. The + array must {\em not} be deallocated. *} +RETURN {* Integer array contaning the variable numbers or NULL if + {\tt v} is an unknown block. *} +ALSO {* fdd\_varnum *} +*/ +int *fdd_vars(int v) +{ + if (!bddrunning) + { + bdd_error(BDD_RUNNING); + return NULL; + } + + if (v >= fdvarnum || v < 0) + { + bdd_error(BDD_VAR); + return NULL; + } + + return domain[v].ivar; +} + + + +/************************************************************************* + FDD primitives +*************************************************************************/ + +/* +NAME {* fdd\_ithvar *} +SECTION {* fdd *} +SHORT {* the BDD for the i'th FDD set to a specific value *} +PROTO {* BDD fdd_ithvar(int var, int val) *} +DESCR {* Returns the BDD that defines the value {\tt val} for the + finite domain block {\tt var}. The encoding places the + Least Significant Bit at the top of the BDD tree + (which means they will have the lowest variable index). + The returned BDD will be $V_0 \conj V_1 \conj \ldots + \conj V_N$ where each $V_i$ will be in positive or negative form + depending on the value of {\tt val}. *} +RETURN {* The correct BDD or the constant false BDD on error. *} +ALSO {* fdd\_ithset *} +*/ +BDD fdd_ithvar(int var, int val) +{ + int n; + int v=1, tmp; + + if (!bddrunning) + { + bdd_error(BDD_RUNNING); + return bddfalse; + } + + if (var < 0 || var >= fdvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + if (val < 0 || val >= domain[var].realsize) + { + bdd_error(BDD_RANGE); + return bddfalse; + } + + for (n=0 ; n>= 1; + } + + return v; +} + + +/* +NAME {* fdd\_scanvar *} +SECTION {* fdd *} +SHORT {* Finds one satisfying value of a FDD variable *} +PROTO {* int fdd_scanvar(BDD r, int var) *} +DESCR {* Finds one satisfying assignment of the FDD variable {\tt var} in the + BDD {\tt r} and returns this value. *} +RETURN {* The value of a satisfying assignment of {\tt var}. If {\tt r} is + the trivially false BDD, then a negative value is returned. *} +ALSO {* fdd\_scanallvar *} +*/ +int fdd_scanvar(BDD r, int var) +{ + int *allvar; + int res; + + CHECK(r); + if (r == bddfalse) + return -1; + if (var < 0 || var >= fdvarnum) + return bdd_error(BDD_VAR); + + allvar = fdd_scanallvar(r); + res = allvar[var]; + free(allvar); + + return res; +} + + +/* +NAME {* fdd\_scanallvar *} +SECTION {* fdd *} +SHORT {* Finds one satisfying value of all FDD variables *} +PROTO {* int* fdd_scanallvar(BDD r) *} +DESCR {* Finds one satisfying assignment in {\tt r} of all the defined + FDD variables. Each value is stored in an array which is + returned. The size of this array is exactly the number of + FDD variables defined. It is the user's responsibility to + free this array using {\tt free()}. *} +RETURN {* An array with all satisfying values. If {\tt r} is the trivially + false BDD, then NULL is returned. *} +ALSO {* fdd\_scanvar *} +*/ +int* fdd_scanallvar(BDD r) +{ + int n; + char *store; + int *res; + BDD p = r; + + CHECKa(r,NULL); + if (r == bddfalse) + return NULL; + + store = NEW(char,bddvarnum); + for (n=0 ; n=0 ; m--) + if ( store[domain[n].ivar[m]] ) + val = val*2 + 1; + else + val = val*2; + + res[n] = val; + } + + free(store); + + return res; +} + +/* +NAME {* fdd\_ithset *} +SECTION {* fdd *} +SHORT {* the variable set for the i'th finite domain block *} +PROTO {* BDD fdd_ithset(int var) *} +DESCR {* Returns the variable set that contains the variables used to + define the finite domain block {\tt var}. *} +RETURN {* The variable set or the constant false BDD on error. *} +ALSO {* fdd\_ithvar *} +*/ +BDD fdd_ithset(int var) +{ + if (!bddrunning) + { + bdd_error(BDD_RUNNING); + return bddfalse; + } + + if (var < 0 || var >= fdvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + return domain[var].var; +} + +/* +NAME {* fdd\_domain *} +SECTION {* fdd *} +SHORT {* BDD encoding of the domain of a FDD variable *} +PROTO {* BDD fdd_domain(int var) *} +DESCR {* Returns what corresponds to a disjunction of all possible + values of the variable {\tt var}. + This is more efficient than doing + {\tt fdd\_ithvar(var,0) OR fdd\_ithvar(var,1) ...} explicitely + for all values in the domain of {\tt var}. *} +RETURN {* The encoding of the domain*} +*/ +BDD fdd_domain(int var) +{ + int n,val; + Domain *dom; + BDD d; + + if (!bddrunning) + { + bdd_error(BDD_RUNNING); + return bddfalse; + } + + if (var < 0 || var >= fdvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + /* Encode V<=X-1. V is the variables in 'var' and X is the domain size */ + + dom = &domain[var]; + val = dom->realsize-1; + d = bddtrue; + + for (n=0 ; nbinsize ; n++) + { + BDD tmp; + + if (val & 0x1) + tmp = bdd_apply( bdd_nithvar(dom->ivar[n]), d, bddop_or ); + else + tmp = bdd_apply( bdd_nithvar(dom->ivar[n]), d, bddop_and ); + + val >>= 1; + + bdd_addref(tmp); + bdd_delref(d); + d = tmp; + } + + return d; +} + + +/* +NAME {* fdd\_equals *} +SECTION {* fdd *} +SHORT {* returns a BDD setting two FD. blocks equal *} +PROTO {* BDD fdd_equals(int f, int g) *} +DESCR {* Builds a BDD which is true for all the possible assignments to + the variable blocks {\tt f} and {\tt g} that makes the blocks + equal. This is more or less just a shorthand for calling + {\tt fdd\_equ()}. *} +RETURN {* The correct BDD or the constant false on errors. *} +*/ +BDD fdd_equals(int left, int right) +{ + BDD e = bddtrue, tmp1, tmp2; + int n; + + if (!bddrunning) + { + bdd_error(BDD_RUNNING); + return bddfalse; + } + + if (left < 0 || left >= fdvarnum || right < 0 || right >= fdvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + if (domain[left].realsize != domain[right].realsize) + { + bdd_error(BDD_RANGE); + return bddfalse; + } + + for (n=0 ; n"); + } + else + { + set[bddlevel2var[LEVEL(r)]] = 1; + fdd_printset_rec(ofile, LOW(r), set); + + set[bddlevel2var[LEVEL(r)]] = 2; + fdd_printset_rec(ofile, HIGH(r), set); + + set[bddlevel2var[LEVEL(r)]] = 0; + } +} + + +/*======================================================================*/ + +/* +NAME {* fdd\_scanset *} +SECTION {* fdd *} +SHORT {* scans a variable set *} +PROTO {* int fdd_scanset(BDD r, int **varset, int *varnum) *} +DESCR {* Scans the BDD {\tt r} to find all occurences of FDD variables + and then stores these in {\tt varset}. {\tt varset} will be set + to point to an array of size {\tt varnum} which will contain + the indices of the found FDD variables. It is the users + responsibility to free {\tt varset} after use. *} +RETURN {* Zero on success or a negative error code on error. *} +ALSO {* fdd\_makeset *} +*/ +int fdd_scanset(BDD r, int **varset, int *varnum) +{ + int *fv, fn; + int num,n,m,i; + + if (!bddrunning) + return bdd_error(BDD_RUNNING); + + if ((n=bdd_scanset(r, &fv, &fn)) < 0) + return n; + + for (n=0,num=0 ; n= fdvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + for (n=0 ; n last || first < 0 || last >= fdvarnum) + return bdd_error(BDD_VARBLK); + + for (n=first ; n<=last ; n++) + { + bdd_addref(res); + tmp = bdd_apply(domain[n].var, res, bddop_and); + bdd_delref(res); + res = tmp; + } + + err = bdd_addvarblock(res, fixed); + + bdd_delref(res); + return err; +} + + +/* +NAME {* fdd\_setpair *} +SECTION {* fdd *} +SHORT {* defines a pair for two finite domain blocks *} +PROTO {* int fdd_setpair(bddPair *pair, int p1, int p2) *} +DESCR {* Defines each variable in the finite domain block {\tt p1} to + be paired with the corresponding variable in {\tt p2}. The result + is stored in {\tt pair} which must be allocated using + {\tt bdd\_makepair}. *} +RETURN {* Zero on success or a negative error code on error. *} +ALSO {* fdd\_setpairs *} +*/ +int fdd_setpair(bddPair *pair, int p1, int p2) +{ + int n,e; + + if (!bddrunning) + return bdd_error(BDD_RUNNING); + + if (p1<0 || p1>=fdvarnum || p2<0 || p2>=fdvarnum) + return bdd_error(BDD_VAR); + + if (domain[p1].binsize != domain[p2].binsize) + return bdd_error(BDD_VARNUM); + + for (n=0 ; n=fdvarnum || p2[n]<0 || p2[n]>=fdvarnum) + return bdd_error(BDD_VAR); + + for (n=0 ; nivar); + bdd_delref(d->var); +} + + +static void Domain_allocate(Domain* d, int range) +{ + int calcsize = 2; + + if (range <= 0 || range > INT_MAX/2) + { + bdd_error(BDD_RANGE); + return; + } + + d->realsize = range; + d->binsize = 1; + + while (calcsize < range) + { + d->binsize++; + calcsize <<= 1; + } + + d->ivar = (int *)malloc(sizeof(int)*d->binsize); + d->var = bddtrue; +} + + +int *fdddec2bin(int var, int val) +{ + int *res; + int n = 0; + + res = (int *)malloc(sizeof(int)*domain[var].binsize); + memset(res, 0, sizeof(int)*domain[var].binsize); + + while (val > 0) + { + if (val & 0x1) + res[n] = 1; + val >>= 1; + n++; + } + + return res; +} + + +/* EOF */ + +int fdd_overlapdomains(int *doms, int nbdoms) +{ + Domain *d; + int i,j,n; + + if (!bddrunning) + return bdd_error(BDD_RUNNING); + + for (i=0 ; i= fdvarnum) + return bdd_error(BDD_VAR); + } + + /* if (v1 < 0 || v1 >= fdvarnum || v2 < 0 || v2 >= fdvarnum) */ + /* return bdd_error(BDD_VAR); */ + + if (fdvarnum + 1 > fdvaralloc) + { + fdvaralloc += fdvaralloc; + + domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); + if (domain == NULL) + return bdd_error(BDD_MEMORY); + } + + d = &domain[fdvarnum]; + d->realsize = 0; + d->binsize = 0; + for (i=0 ; irealsize += domain[doms[i]].realsize; + d->binsize += domain[doms[i]].binsize; + } + /* d->realsize = domain[v1].realsize * domain[v2].realsize; */ + /* d->binsize = domain[v1].binsize + domain[v2].binsize; */ + d->ivar = (int *)malloc(sizeof(int)*d->binsize); + + j=0; + for (i=0 ; iivar[j++] = domain[doms[i]].ivar[n]; + + /* for (n=0 ; nivar[n] = domain[v1].ivar[n]; */ + /* for (n=0 ; nivar[domain[v1].binsize+n] = domain[v2].ivar[n]; */ + + d->var = bdd_makeset(d->ivar, d->binsize); + bdd_addref(d->var); + + return fdvarnum++; +} diff --git a/sdk/buddy-2.4/src/fdd.h b/sdk/buddy-2.4/src/fdd.h new file mode 100644 index 0000000..754ef92 --- /dev/null +++ b/sdk/buddy-2.4/src/fdd.h @@ -0,0 +1,174 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/fdd.h,v 1.1.1.1 2004/06/25 13:22:40 haimcohen Exp $ + FILE: fdd.h + DESCR: Finite domain data with BDDs + AUTH: Jorn Lind + DATE: (C) february 1999 +*************************************************************************/ + +#ifndef _FDD_H +#define _FDD_H + +#include "bdd.h" + + +#ifdef CPLUSPLUS +extern "C" { +#endif + +/* In file fdd.c */ + +extern int fdd_extdomain(int*, int); +extern int fdd_overlapdomain(int, int); +extern int fdd_overlapdomains(int*, int); +extern void fdd_clearall(void); +extern int fdd_domainnum(void); +extern int fdd_domainsize(int); +extern int fdd_varnum(int); +extern int* fdd_vars(int); +extern BDD fdd_ithvar(int, int); +extern int fdd_scanvar(BDD, int); +extern int* fdd_scanallvar(BDD); +extern BDD fdd_ithset(int); +extern BDD fdd_domain(int); +extern BDD fdd_equals(int, int); +extern bddfilehandler fdd_file_hook(bddfilehandler); +#ifdef CPLUSPLUS +extern bddstrmhandler fdd_strm_hook(bddstrmhandler); +#endif +extern void fdd_printset(BDD); +extern void fdd_fprintset(FILE*, BDD); +extern int fdd_scanset(BDD, int**, int*); +extern BDD fdd_makeset(int*, int); +extern int fdd_intaddvarblock(int, int, int); +extern int fdd_setpair(bddPair*, int, int); +extern int fdd_setpairs(bddPair*, int*, int*, int); + +#ifdef CPLUSPLUS +} +#endif + +/************************************************************************* + If this file is included from a C++ compiler then the following + classes, wrappers and hacks are supplied. +*************************************************************************/ +#ifdef CPLUSPLUS + + /* FDD extensions */ + +inline bdd fdd_ithvarpp(int var, int val) +{ return fdd_ithvar(var, val); } + +inline bdd fdd_ithsetpp(int var) +{ return fdd_ithset(var); } + +inline bdd fdd_domainpp(int var) +{ return fdd_domain(var); } + +inline int fdd_scanvar(const bdd &r, int var) +{ return fdd_scanvar(r.root, var); } + +inline int* fdd_scanallvar(const bdd &r) +{ return fdd_scanallvar(r.root); } + +inline bdd fdd_equalspp(int left, int right) +{ return fdd_equals(left, right); } + +inline void fdd_printset(const bdd &r) +{ fdd_printset(r.root); } + +inline void fdd_fprintset(FILE* ofile, const bdd &r) +{ fdd_fprintset(ofile, r.root); } + +inline int fdd_scanset(const bdd &r, int *&v, int &n) +{ return fdd_scanset(r.root, &v, &n); } + +inline bdd fdd_makesetpp(int *v, int n) +{ return fdd_makeset(v,n); } + +#if 0 +inline bdd* fdd_conpp(int bitnum, int var) +{ return fdd_transfer( bitnum, fdd_con(bitnum, var) ); } + +inline bdd* fdd_varpp(int bitnum, int var) +{ return fdd_transfer( bitnum, fdd_var(bitnum, var) ); } + +extern int fdd_isconst(int bitnum, bdd *e); +extern int fdd_val(int bitnum, bdd *e); + +inline bdd* fdd_add(int bitnum, bdd *left, bdd *right) +{ return fdd_termopr(bitnum, left, right,bdd::fddAdd); } + +inline bdd* fdd_sub(int bitnum, bdd *left, bdd *right) +{ return fdd_termopr(bitnum, left, right,bdd::fddSub); } + +inline bdd* fdd_shl(int bitnum, bdd *expr, bdd c) +{ return fdd_shift(bitnum, expr, c, bdd::fddShl); } + +inline bdd* fdd_shr(int bitnum, bdd *expr, bdd c) +{ return fdd_shift(bitnum, expr, c, bdd::fddShr); } + +inline bdd fdd_lth(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddLth); } + +inline bdd fdd_lte(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddLte); } + +inline bdd fdd_gth(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddGth); } + +inline bdd fdd_gte(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddGte); } + +inline bdd fdd_equ(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddEqu); } + +inline bdd fdd_neq(int bitnum, bdd *left, bdd *right) +{ return fdd_relopr(bitnum, left, right, bdd::fddNeq); } +#endif + + /* Hacks to allow for overloading of return-types only */ +#define fdd_ithvar fdd_ithvarpp +#define fdd_ithset fdd_ithsetpp +#define fdd_domain fdd_domainpp +#define fdd_equals fdd_equalspp +#define fdd_makeset fdd_makesetpp +#define fdd_con fdd_conpp +#define fdd_var fdd_varpp + + +#endif /* CPLUSPLUS */ + +#endif /* _FDD_H */ + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/imatrix.c b/sdk/buddy-2.4/src/imatrix.c new file mode 100644 index 0000000..eb21ea4 --- /dev/null +++ b/sdk/buddy-2.4/src/imatrix.c @@ -0,0 +1,149 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + FILE: imatrix.cc + DESCR: Interaction matrix + AUTH: Jorn Lind + DATE: (C) february 2000 +*************************************************************************/ +#include +#include +#include +#include "kernel.h" +#include "imatrix.h" + +/************************************************************************* +*************************************************************************/ + +imatrix* imatrixNew(int size) +{ + imatrix *mtx = NEW(imatrix,1); + int n,m; + + if (!mtx) + return NULL; + + if ((mtx->rows=NEW(char*,size)) == NULL) + { + free(mtx); + return NULL; + } + + for (n=0 ; nrows[n]=NEW(char,size/8+1)) == NULL) + { + for (m=0 ; mrows[m]); + free(mtx); + return NULL; + } + + memset(mtx->rows[n], 0, size/8+1); + } + + mtx->size = size; + + return mtx; +} + + +void imatrixDelete(imatrix *mtx) +{ + int n; + + for (n=0 ; nsize ; n++) + free(mtx->rows[n]); + free(mtx->rows); + free(mtx); +} + + +/*======================================================================*/ + +void imatrixFPrint(imatrix *mtx, FILE *ofile) +{ + int x,y; + + fprintf(ofile, " "); + for (x=0 ; xsize ; x++) + fprintf(ofile, "%c", x < 26 ? (x+'a') : (x-26)+'A'); + fprintf(ofile, "\n"); + + for (y=0 ; ysize ; y++) + { + fprintf(ofile, "%2d %c", y, y < 26 ? (y+'a') : (y-26)+'A'); + for (x=0 ; xsize ; x++) + fprintf(ofile, "%c", imatrixDepends(mtx,y,x) ? 'x' : ' '); + fprintf(ofile, "\n"); + } +} + + +void imatrixPrint(imatrix *mtx) +{ + imatrixFPrint(mtx, stdout); +} + + +void imatrixSet(imatrix *mtx, int a, int b) +{ + mtx->rows[a][b/8] |= 1<<(b%8); +} + + +void imatrixClr(imatrix *mtx, int a, int b) +{ + mtx->rows[a][b/8] &= ~(1<<(b%8)); +} + + +int imatrixDepends(imatrix *mtx, int a, int b) +{ + return mtx->rows[a][b/8] & (1<<(b%8)); +} + + +/*======================================================================*/ + +#if 0 +void main(void) +{ + imatrix *m = imatrixNew(16); + + imatrixSet(m,0,2); + imatrixSet(m,8,8); + imatrixSet(m,15,15); + + imatrixPrint(m); +} +#endif + +/* EOF */ diff --git a/sdk/buddy-2.4/src/imatrix.h b/sdk/buddy-2.4/src/imatrix.h new file mode 100644 index 0000000..bca711e --- /dev/null +++ b/sdk/buddy-2.4/src/imatrix.h @@ -0,0 +1,59 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + FILE: imatrix.h + DESCR: Interaction matrix + AUTH: Jorn Lind + DATE: (C) february 2000 +*************************************************************************/ + +#ifndef _IMATRIX_H +#define _IMATRIX_H + +typedef struct _imatrix +{ + char **rows; + int size; +} imatrix; + + +extern imatrix* imatrixNew(int); +extern void imatrixDelete(imatrix*); +extern void imatrixFPrint(imatrix*,FILE *); +extern void imatrixPrint(imatrix*); +extern void imatrixSet(imatrix*,int,int); +extern void imatrixClr(imatrix*,int,int); +extern int imatrixDepends(imatrix*,int,int); + + +#endif /* _IMATRIX_H */ + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/kernel.c b/sdk/buddy-2.4/src/kernel.c new file mode 100644 index 0000000..cd5c1f3 --- /dev/null +++ b/sdk/buddy-2.4/src/kernel.c @@ -0,0 +1,1496 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/kernel.c,v 1.2 2004/07/13 21:04:36 haimcohen Exp $ + FILE: kernel.c + DESCR: implements the bdd kernel functions. + AUTH: Jorn Lind + DATE: (C) june 1997 + + WARNING: Do not use pointers to nodes across makenode calls, + as makenode may resize/move the nodetable. + +*************************************************************************/ +#include "config.h" +#include +#include +#include +#include +#include + +#include "kernel.h" +#include "cache.h" +#include "prime.h" + +/************************************************************************* + Various definitions and global variables +*************************************************************************/ + +/*=== EXTERNAL VARIABLES FOR PACKAGE USERS =============================*/ + +/* +NAME {* bddtrue *} +SECTION {* kernel *} +SHORT {* the constant true bdd *} +PROTO {* extern const BDD bddtrue; *} +DESCR {* This bdd holds the constant true value *} +ALSO {* bddfalse, bdd\_true, bdd\_false *} +*/ +const BDD bddtrue=1; /* The constant true bdd */ + +/* +NAME {* bddfalse*} +SECTION {* kernel *} +SHORT {* the constant false bdd *} +PROTO {* extern const BDD bddfalse; *} +DESCR {* This bdd holds the constant false value *} +ALSO {* bddtrue, bdd\_true, bdd\_false *} +*/ +const BDD bddfalse=0; /* The constant false bdd */ + + +/*=== INTERNAL DEFINITIONS =============================================*/ + +/* Min. number of nodes (%) that has to be left after a garbage collect + unless a resize should be done. */ +static int minfreenodes=20; + + +/*=== GLOBAL KERNEL VARIABLES ==========================================*/ + +int bddrunning; /* Flag - package initialized */ +int bdderrorcond; /* Some error condition */ +int bddnodesize; /* Number of allocated nodes */ +int bddmaxnodesize; /* Maximum allowed number of nodes */ +int bddmaxnodeincrease; /* Max. # of nodes used to inc. table */ +BddNode* bddnodes; /* All of the bdd nodes */ +int bddfreepos; /* First free node */ +int bddfreenum; /* Number of free nodes */ +long int bddproduced; /* Number of new nodes ever produced */ +int bddvarnum; /* Number of defined BDD variables */ +int* bddrefstack; /* Internal node reference stack */ +int* bddrefstacktop; /* Internal node reference stack top */ +int* bddvar2level; /* Variable -> level table */ +int* bddlevel2var; /* Level -> variable table */ +jmp_buf bddexception; /* Long-jump point for interrupting calc. */ +int bddresized; /* Flag indicating a resize of the nodetable */ + +bddCacheStat bddcachestats; + + +/*=== PRIVATE KERNEL VARIABLES =========================================*/ + +static BDD* bddvarset; /* Set of defined BDD variables */ +static int gbcollectnum; /* Number of garbage collections */ +static int cachesize; /* Size of the operator caches */ +static long int gbcclock; /* Clock ticks used in GBC */ +static int usednodes_nextreorder; /* When to do reorder next time */ +static bddinthandler err_handler; /* Error handler */ +static bddgbchandler gbc_handler; /* Garbage collection handler */ +static bdd2inthandler resize_handler; /* Node-table-resize handler */ + + + /* Strings for all error mesages */ +static char *errorstrings[BDD_ERRNUM] = +{ "Out of memory", "Unknown variable", "Value out of range", + "Unknown BDD root dereferenced", "bdd_init() called twice", + "File operation failed", "Incorrect file format", + "Variables not in ascending order", "User called break", + "Mismatch in size of variable sets", + "Cannot allocate fewer nodes than already in use", + "Unknown operator", "Illegal variable set", + "Bad variable block operation", + "Trying to decrease the number of variables", + "Trying to replace with variables already in the bdd", + "Number of nodes reached user defined maximum", + "Unknown BDD - was not in node table", + "Bad size argument", + "Mismatch in bitvector size", + "Illegal shift-left/right parameter", + "Division by zero" }; + + +/*=== OTHER INTERNAL DEFINITIONS =======================================*/ + +#define NODEHASH(lvl,l,h) (TRIPLE(lvl,l,h) % bddnodesize) + + +/************************************************************************* + BDD misc. user operations +*************************************************************************/ + +/* +NAME {* bdd\_init *} +SECTION {* kernel *} +SHORT {* initializes the BDD package *} +PROTO {* int bdd_init(int nodesize, int cachesize) *} +DESCR {* This function initiates the bdd package and {\em must} be called + before any bdd operations are done. The argument {\tt nodesize} + is the initial number of nodes in the nodetable and {\tt cachesize} + is the fixed size of the internal caches. Typical values for + {\tt nodesize} are 10000 nodes for small test examples and up to + 1000000 nodes for large examples. A cache size of 10000 seems to + work good even for large examples, but lesser values should do it + for smaller examples. + + The number of cache entries can also be set to depend on the size + of the nodetable using a call to {\tt bdd\_setcacheratio}. + + The initial number of nodes is not critical for any bdd operation + as the table will be resized whenever there are to few nodes left + after a garbage collection. But it does have some impact on the + efficency of the operations. *} +RETURN {* If no errors occur then 0 is returned, otherwise + a negative error code. *} +ALSO {* bdd\_done, bdd\_resize\_hook *} +*/ +int bdd_init(int initnodesize, int cs) +{ + int n, err; + + if (bddrunning) + return bdd_error(BDD_RUNNING); + + bddnodesize = bdd_prime_gte(initnodesize); + + if ((bddnodes=(BddNode*)malloc(sizeof(BddNode)*bddnodesize)) == NULL) + return bdd_error(BDD_MEMORY); + + bddresized = 0; + + for (n=0 ; n MAXVAR) + { + bdd_error(BDD_RANGE); + return bddfalse; + } + + if (num < bddvarnum) + return bdd_error(BDD_DECVNUM); + if (num == bddvarnum) + return 0; + + if (bddvarset == NULL) + { + if ((bddvarset=(BDD*)malloc(sizeof(BDD)*num*2)) == NULL) + return bdd_error(BDD_MEMORY); + if ((bddlevel2var=(int*)malloc(sizeof(int)*(num+1))) == NULL) + { + free(bddvarset); + return bdd_error(BDD_MEMORY); + } + if ((bddvar2level=(int*)malloc(sizeof(int)*(num+1))) == NULL) + { + free(bddvarset); + free(bddlevel2var); + return bdd_error(BDD_MEMORY); + } + } + else + { + if ((bddvarset=(BDD*)realloc(bddvarset,sizeof(BDD)*num*2)) == NULL) + return bdd_error(BDD_MEMORY); + if ((bddlevel2var=(int*)realloc(bddlevel2var,sizeof(int)*(num+1))) == NULL) + { + free(bddvarset); + return bdd_error(BDD_MEMORY); + } + if ((bddvar2level=(int*)realloc(bddvar2level,sizeof(int)*(num+1))) == NULL) + { + free(bddvarset); + free(bddlevel2var); + return bdd_error(BDD_MEMORY); + } + } + + if (bddrefstack != NULL) + free(bddrefstack); + bddrefstack = bddrefstacktop = (int*)malloc(sizeof(int)*(num*3+4)); + + for(bdv=bddvarnum ; bddvarnum < num; bddvarnum++) + { + bddvarset[bddvarnum*2] = PUSHREF( bdd_makenode(bddvarnum, 0, 1) ); + bddvarset[bddvarnum*2+1] = bdd_makenode(bddvarnum, 1, 0); + POPREF(1); + + if (bdderrorcond) + { + bddvarnum = bdv; + return -bdderrorcond; + } + + bddnodes[bddvarset[bddvarnum*2]].refcou = MAXREF; + bddnodes[bddvarset[bddvarnum*2+1]].refcou = MAXREF; + bddlevel2var[bddvarnum] = bddvarnum; + bddvar2level[bddvarnum] = bddvarnum; + } + + LEVEL(0) = num; + LEVEL(1) = num; + bddvar2level[num] = num; + bddlevel2var[num] = num; + + bdd_pairs_resize(oldbddvarnum, bddvarnum); + bdd_operator_varresize(); + + bdd_enable_reorder(); + + return 0; +} + + +/* +NAME {* bdd\_extvarnum *} +SECTION {* kernel *} +SHORT {* add extra BDD variables *} +PROTO {* int bdd_extvarnum(int num) *} +DESCR {* Extends the current number of allocated BDD variables with + {\tt num} extra variables. *} +RETURN {* The old number of allocated variables or a negative error code. *} +ALSO {* bdd\_setvarnum, bdd\_ithvar, bdd\_nithvar *} +*/ +int bdd_extvarnum(int num) +{ + int start = bddvarnum; + + if (num < 0 || num > 0x3FFFFFFF) + return bdd_error(BDD_RANGE); + + bdd_setvarnum(bddvarnum+num); + return start; +} + + +/* +NAME {* bdd\_error\_hook *} +SECTION {* kernel *} +SHORT {* set a handler for error conditions *} +PROTO {* bddinthandler bdd_error_hook(bddinthandler handler) *} +DESCR {* Whenever an error occurs in the bdd package a test is done to + see if an error handler is supplied by the user and if such exists + then it will be called + with an error code in the variable {\tt errcode}. The handler may + then print any usefull information and return or exit afterwards. + + This function sets the handler to be {\tt handler}. If a {\tt NULL} + argument is supplied then no calls are made when an error occurs. + Possible error codes are found in {\tt bdd.h}. The default handler + is {\tt bdd\_default\_errhandler} which will use {\tt exit()} to + terminate the program. + + Any handler should be defined like this: + \begin{verbatim} +void my_error_handler(int errcode) +{ + ... +} +\end{verbatim} *} +RETURN {* The previous handler *} +ALSO {* bdd\_errstring *} +*/ +bddinthandler bdd_error_hook(bddinthandler handler) +{ + bddinthandler tmp = err_handler; + err_handler = handler; + return tmp; +} + + +/* +NAME {* bdd\_clear\_error *} +SECTION {* kernel *} +SHORT {* clears an error condition in the kernel *} +PROTO {* void bdd_clear_error(void) *} +DESCR {* The BuDDy kernel may at some point run out of new ROBDD nodes if + a maximum limit is set with {\tt bdd\_setmaxnodenum}. In this case + the current error handler is called and an internal error flag + is set. Further calls to BuDDy will always return {\tt bddfalse}. + From here BuDDy must either be restarted or {\tt bdd\_clear\_error} + may be called after action is taken to let BuDDy continue. This may + not be especially usefull since the default error handler exits + the program - other needs may of course exist.*} +ALSO {* bdd\_error\_hook, bdd\_setmaxnodenum *} +*/ +void bdd_clear_error(void) +{ + bdderrorcond = 0; + bdd_operator_reset(); +} + + +/* +NAME {* bdd\_gbc\_hook *} +SECTION {* kernel *} +SHORT {* set a handler for garbage collections *} +PROTO {* bddgbchandler bdd_gbc_hook(bddgbchandler handler) *} +DESCR {* Whenever a garbage collection is required, a test is done to + see if a handler for this event is supplied by the user and if such + exists then it is called, both before and after the garbage collection + takes places. This is indicated by an integer flag {\tt pre} passed to + the handler, which will be one before garbage collection and zero + after garbage collection. + + This function sets the handler to be {\tt handler}. If a {\tt + NULL} argument is supplied then no calls are made when a + garbage collection takes place. The argument {\tt pre} + indicates pre vs. post garbage collection and the argument + {\tt stat} contains information about the garbage + collection. The default handler is {\tt bdd\_default\_gbchandler}. + + Any handler should be defined like this: + \begin{verbatim} +void my_gbc_handler(int pre, bddGbcStat *stat) +{ + ... +} +\end{verbatim} *} +RETURN {* The previous handler *} +ALSO {* bdd\_resize\_hook, bdd\_reorder\_hook *} */ +bddgbchandler bdd_gbc_hook(bddgbchandler handler) +{ + bddgbchandler tmp = gbc_handler; + gbc_handler = handler; + return tmp; +} + + +/* +NAME {* bdd\_resize\_hook *} +SECTION {* kernel *} +SHORT {* set a handler for nodetable resizes *} +PROTO {* bdd2inthandler bdd_resize_hook(bdd2inthandler handler) *} +DESCR {* Whenever it is impossible to get enough free nodes by a garbage + collection then the node table is resized and a test is done to see + if a handler is supllied by the user for this event. If so then + it is called with {\tt oldsize} being the old nodetable size and + {\tt newsize} being the new nodetable size. + + This function sets the handler to be {\tt handler}. If a {\tt NULL} + argument is supplied then no calls are made when a table resize + is done. No default handler is supplied. + + Any handler should be defined like this: + \begin{verbatim} +void my_resize_handler(int oldsize, int newsize) +{ + ... +} +\end{verbatim} *} +RETURN {* The previous handler *} +ALSO {* bdd\_gbc\_hook, bdd\_reorder\_hook, bdd\_setminfreenodes *} +*/ +bdd2inthandler bdd_resize_hook(bdd2inthandler handler) +{ + bdd2inthandler tmp = handler; + resize_handler = handler; + return tmp; +} + + +/* +NAME {* bdd\_setmaxincrease *} +SECTION {* kernel *} +SHORT {* set max. number of nodes used to increase node table *} +PROTO {* int bdd_setmaxincrease(int size) *} +DESCR {* The node table is expanded by doubling the size of the table + when no more free nodes can be found, but a maximum for the + number of new nodes added can be set with {\tt bdd\_maxincrease} + to {\tt size} nodes. The default is 50000 nodes (1 Mb). *} +RETURN {* The old threshold on succes, otherwise a negative error code. *} +ALSO {* bdd\_setmaxnodenum, bdd\_setminfreenodes *} +*/ +int bdd_setmaxincrease(int size) +{ + int old = bddmaxnodeincrease; + + if (size < 0) + return bdd_error(BDD_SIZE); + + bddmaxnodeincrease = size; + return old; +} + +/* +NAME {* bdd\_setmaxnodenum *} +SECTION {* kernel *} +SHORT {* set the maximum available number of bdd nodes *} +PROTO {* int bdd_setmaxnodenum(int size) *} +DESCR {* This function sets the maximal number of bdd nodes the package may + allocate before it gives up a bdd operation. The + argument {\tt size} is the absolute maximal number of nodes there + may be allocated for the nodetable. Any attempt to allocate more + nodes results in the constant false being returned and the error + handler being called until some nodes are deallocated. + A value of 0 is interpreted as an unlimited amount. + It is {\em not} possible to specify + fewer nodes than there has already been allocated. *} +RETURN {* The old threshold on succes, otherwise a negative error code. *} +ALSO {* bdd\_setmaxincrease, bdd\_setminfreenodes *} +*/ +int bdd_setmaxnodenum(int size) +{ + if (size > bddnodesize || size == 0) + { + int old = bddmaxnodesize; + bddmaxnodesize = size; + return old; + } + + return bdd_error(BDD_NODES); +} + + +/* +NAME {* bdd\_setminfreenodes *} +SECTION {* kernel *} +SHORT {* set min. no. of nodes to be reclaimed after GBC. *} +PROTO {* int bdd_setminfreenodes(int n) *} +DESCR {* Whenever a garbage collection is executed the number of free + nodes left are checked to see if a resize of the node table is + required. If $X = (\mathit{bddfreenum}*100)/\mathit{maxnum}$ + is less than or + equal to {\tt n} then a resize is initiated. The range of + {\tt X} is of course $0\ldots 100$ and has some influence + on how fast the package is. A low number means harder attempts + to avoid resizing and saves space, and a high number reduces + the time used in garbage collections. The default value is + 20. *} +RETURN {* The old threshold on succes, otherwise a negative error code. *} +ALSO {* bdd\_setmaxnodenum, bdd\_setmaxincrease *} +*/ +int bdd_setminfreenodes(int mf) +{ + int old = minfreenodes; + + if (mf<0 || mf>100) + return bdd_error(BDD_RANGE); + + minfreenodes = mf; + return old; +} + + +/* +NAME {* bdd\_getnodenum *} +SECTION {* kernel *} +SHORT {* get the number of active nodes in use *} +PROTO {* int bdd_getnodenum(void) *} +DESCR {* Returns the number of nodes in the nodetable that are + currently in use. Note that dead nodes that have not been + reclaimed yet + by a garbage collection are counted as active. *} +RETURN {* The number of nodes. *} +ALSO {* bdd\_getallocnum, bdd\_setmaxnodenum *} +*/ +int bdd_getnodenum(void) +{ + return bddnodesize - bddfreenum; +} + + +/* +NAME {* bdd\_getallocnum *} +SECTION {* kernel *} +SHORT {* get the number of allocated nodes *} +PROTO {* int bdd_getallocnum(void) *} +DESCR {* Returns the number of nodes currently allocated. This includes + both dead and active nodes. *} +RETURN {* The number of nodes. *} +ALSO {* bdd\_getnodenum, bdd\_setmaxnodenum *} +*/ +int bdd_getallocnum(void) +{ + return bddnodesize; +} + + +/* +NAME {* bdd\_isrunning *} +SECTION {* kernel *} +SHORT {* test whether the package is started or not *} +PROTO {* void bdd_isrunning(void) *} +DESCR {* This function tests the internal state of the package and returns + a status. *} +RETURN {* 1 (true) if the package has been started, otherwise 0. *} +ALSO {* bdd\_init, bdd\_done *} +*/ +int bdd_isrunning(void) +{ + return bddrunning; +} + + +/* +NAME {* bdd\_versionstr *} +SECTION {* kernel *} +SHORT {* returns a text string with version information *} +PROTO {* char* bdd_versionstr(void) *} +DESCR {* This function returns a text string with information about the + version of the bdd package. *} +ALSO {* bdd\_versionnum *} +*/ +char *bdd_versionstr(void) +{ + static char str[] = "BuDDy - release " PACKAGE_VERSION; + return str; +} + + +/* +NAME {* bdd\_versionnum *} +SECTION {* kernel *} +SHORT {* returns the version number of the bdd package *} +PROTO {* int bdd_versionnum(void) *} +DESCR {* This function returns the version number of the bdd package. The + number is in the range 10-99 for version 1.0 to 9.9. *} +ALSO {* bdd\_versionstr *} +*/ +int bdd_versionnum(void) +{ + return MAJOR_VERSION * 10 + MINOR_VERSION; +} + + +/* +NAME {* bdd\_stats *} +SECTION {* kernel *} +SHORT {* returns some status information about the bdd package *} +PROTO {* void bdd_stats(bddStat* stat) *} +DESCR {* This function acquires information about the internal state of + the bdd package. The status information is written into the + {\tt stat} argument. *} +ALSO {* bddStat *} +*/ +void bdd_stats(bddStat *s) +{ + s->produced = bddproduced; + s->nodenum = bddnodesize; + s->maxnodenum = bddmaxnodesize; + s->freenodes = bddfreenum; + s->minfreenodes = minfreenodes; + s->varnum = bddvarnum; + s->cachesize = cachesize; + s->gbcnum = gbcollectnum; +} + + + +/* +NAME {* bdd\_cachestats *} +SECTION {* kernel *} +SHORT {* Fetch cache access usage *} +PROTO {* void bdd_cachestats(bddCacheStat *s) *} +DESCR {* Fetches cache usage information and stores it in {\tt s}. The + fields of {\tt s} can be found in the documentaion for + {\tt bddCacheStat}. This function may or may not be compiled + into the BuDDy package - depending on the setup at compile + time of BuDDy. *} +ALSO {* bddCacheStat, bdd\_printstat *} +*/ +void bdd_cachestats(bddCacheStat *s) +{ + *s = bddcachestats; +} + + +/* +NAME {* bdd\_printstat *} +EXTRA {* bdd\_fprintstat *} +SECTION {* kernel *} +SHORT {* print cache statistics *} +PROTO {* void bdd_printstat(void) +void bdd_fprintstat(FILE *ofile) *} +DESCR {* Prints information about the cache performance on standard output + (or the supplied file). The information contains the number of + accesses to the unique node table, the number of times a node + was (not) found there and how many times a hash chain had to + traversed. Hit and miss count is also given for the operator + caches. *} +ALSO {* bddCacheStat, bdd\_cachestats *} +*/ +void bdd_fprintstat(FILE *ofile) +{ + bddCacheStat s; + bdd_cachestats(&s); + + fprintf(ofile, "\nCache statistics\n"); + fprintf(ofile, "----------------\n"); + + fprintf(ofile, "Unique Access: %ld\n", s.uniqueAccess); + fprintf(ofile, "Unique Chain: %ld\n", s.uniqueChain); + fprintf(ofile, "Unique Hit: %ld\n", s.uniqueHit); + fprintf(ofile, "Unique Miss: %ld\n", s.uniqueMiss); + fprintf(ofile, "=> Hit rate = %.2f\n", + (s.uniqueHit+s.uniqueMiss > 0) ? + ((float)s.uniqueHit)/((float)s.uniqueHit+s.uniqueMiss) : 0); + fprintf(ofile, "Operator Hits: %ld\n", s.opHit); + fprintf(ofile, "Operator Miss: %ld\n", s.opMiss); + fprintf(ofile, "=> Hit rate = %.2f\n", + (s.opHit+s.opMiss > 0) ? + ((float)s.opHit)/((float)s.opHit+s.opMiss) : 0); + fprintf(ofile, "Swap count = %ld\n", s.swapCount); +} + + +void bdd_printstat(void) +{ + bdd_fprintstat(stdout); +} + + +/************************************************************************* + Error handler +*************************************************************************/ + +/* +NAME {* bdd\_errstring *} +SECTION {* kernel *} +SHORT {* converts an error code to a string*} +PROTO {* const char *bdd_errstring(int errorcode) *} +DESCR {* Converts a negative error code {\tt errorcode} to a descriptive + string that can be used for error handling. *} +RETURN {* An error description string if {\tt e} is known, otherwise {\tt NULL}. *} +ALSO {* bdd\_err\_hook *} +*/ +const char *bdd_errstring(int e) +{ + e = abs(e); + if (e<1 || e>BDD_ERRNUM) + return NULL; + return errorstrings[e-1]; +} + + +void bdd_default_errhandler(int e) +{ + fprintf(stderr, "BDD error: %s\n", bdd_errstring(e)); + exit(1); +} + + +int bdd_error(int e) +{ + if (err_handler != NULL) + err_handler(e); + + return e; +} + + +/************************************************************************* + BDD primitives +*************************************************************************/ + +/* +NAME {* bdd\_true *} +SECTION {* kernel *} +SHORT {* returns the constant true bdd *} +PROTO {* BDD bdd_true(void) *} +DESCR {* This function returns the constant true bdd and can freely be + used together with the {\tt bddtrue} and {\tt bddfalse} + constants. *} +RETURN {* The constant true bdd *} +ALSO {* bdd\_false, bddtrue, bddfalse *} +*/ +BDD bdd_true(void) +{ + return 1; +} + + +/* +NAME {* bdd\_false *} +SECTION {* kernel *} +SHORT {* returns the constant false bdd *} +PROTO {* BDD bdd_false(void) *} +DESCR {* This function returns the constant false bdd and can freely be + used together with the {\tt bddtrue} and {\tt bddfalse} + constants. *} +RETURN {* The constant false bdd *} +ALSO {* bdd\_true, bddtrue, bddfalse *} +*/ +BDD bdd_false(void) +{ + return 0; +} + + +/* +NAME {* bdd\_ithvar *} +SECTION {* kernel *} +SHORT {* returns a bdd representing the I'th variable *} +PROTO {* BDD bdd_ithvar(int var) *} +DESCR {* This function is used to get a bdd representing the I'th + variable (one node with the childs true and false). The requested + variable must be in the range define by {\tt + bdd\_setvarnum} starting with 0 being the first. For ease + of use then the bdd returned from {\tt bdd\_ithvar} does + not have to be referenced counted with a call to {\tt + bdd\_addref}. The initial variable order is defined by the + the index {\tt var} that also defines the position in the + variable order -- variables with lower indecies are before + those with higher indecies. *} +RETURN {* The I'th variable on succes, otherwise the constant false bdd *} +ALSO {* bdd\_setvarnum, bdd\_nithvar, bddtrue, bddfalse *} */ +BDD bdd_ithvar(int var) +{ + if (var < 0 || var >= bddvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + return bddvarset[var*2]; +} + + +/* +NAME {* bdd\_nithvar *} +SECTION {* kernel *} +SHORT {* returns a bdd representing the negation of the I'th variable *} +PROTO {* BDD bdd_nithvar(int var) *} +DESCR {* This function is used to get a bdd representing the negation of + the I'th variable (one node with the childs false and true). + The requested variable must be in the range define by + {\tt bdd\_setvarnum} starting with 0 being the first. For ease of + use then the bdd returned from {\tt bdd\_nithvar} does not have + to be referenced counted with a call to {\tt bdd\_addref}. *} +RETURN {* The negated I'th variable on succes, otherwise the constant false bdd *} +ALSO {* bdd\_setvarnum, bdd\_ithvar, bddtrue, bddfalse *} +*/ +BDD bdd_nithvar(int var) +{ + if (var < 0 || var >= bddvarnum) + { + bdd_error(BDD_VAR); + return bddfalse; + } + + return bddvarset[var*2+1]; +} + + +/* +NAME {* bdd\_varnum *} +SECTION {* kernel *} +SHORT {* returns the number of defined variables *} +PROTO {* int bdd_varnum(void) *} +DESCR {* This function returns the number of variables defined by + a call to {\tt bdd\_setvarnum}.*} +RETURN {* The number of defined variables *} +ALSO {* bdd\_setvarnum, bdd\_ithvar *} +*/ +int bdd_varnum(void) +{ + return bddvarnum; +} + + +/* +NAME {* bdd\_var *} +SECTION {* info *} +SHORT {* gets the variable labeling the bdd *} +PROTO {* int bdd_var(BDD r) *} +DESCR {* Gets the variable labeling the bdd {\tt r}. *} +RETURN {* The variable number. *} +*/ +int bdd_var(BDD root) +{ + CHECK(root); + if (root < 2) + return bdd_error(BDD_ILLBDD); + + return (bddlevel2var[LEVEL(root)]); +} + + +/* +NAME {* bdd\_low *} +SECTION {* info *} +SHORT {* gets the false branch of a bdd *} +PROTO {* BDD bdd_low(BDD r) *} +DESCR {* Gets the false branch of the bdd {\tt r}. *} +RETURN {* The bdd of the false branch *} +ALSO {* bdd\_high *} +*/ +BDD bdd_low(BDD root) +{ + CHECK(root); + if (root < 2) + return bdd_error(BDD_ILLBDD); + + return (LOW(root)); +} + + +/* +NAME {* bdd\_high *} +SECTION {* info *} +SHORT {* gets the true branch of a bdd *} +PROTO {* BDD bdd_high(BDD r) *} +DESCR {* Gets the true branch of the bdd {\tt r}. *} +RETURN {* The bdd of the true branch *} +ALSO {* bdd\_low *} +*/ +BDD bdd_high(BDD root) +{ + CHECK(root); + if (root < 2) + return bdd_error(BDD_ILLBDD); + + return (HIGH(root)); +} + + + +/************************************************************************* + Garbage collection and node referencing +*************************************************************************/ + +void bdd_default_gbchandler(int pre, bddGbcStat *s) +{ + if (!pre) + { + printf("Garbage collection #%d: %d nodes / %d free", + s->num, s->nodes, s->freenodes); + printf(" / %.1fs / %.1fs total\n", + (float)s->time/(float)(CLOCKS_PER_SEC), + (float)s->sumtime/(float)CLOCKS_PER_SEC); + } +} + + +static void bdd_gbc_rehash(void) +{ + int n; + + bddfreepos = 0; + bddfreenum = 0; + + for (n=bddnodesize-1 ; n>=2 ; n--) + { + register BddNode *node = &bddnodes[n]; + + if (LOWp(node) != -1) + { + register unsigned int hash; + + hash = NODEHASH(LEVELp(node), LOWp(node), HIGHp(node)); + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = n; + } + else + { + node->next = bddfreepos; + bddfreepos = n; + bddfreenum++; + } + } +} + + +void bdd_gbc(void) +{ + int *r; + int n; + long int c2, c1 = clock(); + + if (gbc_handler != NULL) + { + bddGbcStat s; + s.nodes = bddnodesize; + s.freenodes = bddfreenum; + s.time = 0; + s.sumtime = gbcclock; + s.num = gbcollectnum; + gbc_handler(1, &s); + } + + for (r=bddrefstack ; r 0) + bdd_mark(n); + bddnodes[n].hash = 0; + } + + bddfreepos = 0; + bddfreenum = 0; + + for (n=bddnodesize-1 ; n>=2 ; n--) + { + register BddNode *node = &bddnodes[n]; + + if ((LEVELp(node) & MARKON) && LOWp(node) != -1) + { + register unsigned int hash; + + LEVELp(node) &= MARKOFF; + hash = NODEHASH(LEVELp(node), LOWp(node), HIGHp(node)); + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = n; + } + else + { + LOWp(node) = -1; + node->next = bddfreepos; + bddfreepos = n; + bddfreenum++; + } + } + + bdd_operator_reset(); + + c2 = clock(); + gbcclock += c2-c1; + gbcollectnum++; + + if (gbc_handler != NULL) + { + bddGbcStat s; + s.nodes = bddnodesize; + s.freenodes = bddfreenum; + s.time = c2-c1; + s.sumtime = gbcclock; + s.num = gbcollectnum; + gbc_handler(0, &s); + } +} + + +/* +NAME {* bdd\_addref *} +SECTION {* kernel *} +SHORT {* increases the reference count on a node *} +PROTO {* BDD bdd_addref(BDD r) *} +DESCR {* Reference counting is done on externaly referenced nodes only + and the count for a specific node {\tt r} can and must be + increased using this function to avoid loosing the node in the next + garbage collection. *} +ALSO {* bdd\_delref *} +RETURN {* The BDD node {\tt r}. *} +*/ +BDD bdd_addref(BDD root) +{ + if (root < 2 || !bddrunning) + return root; + if (root >= bddnodesize) + return bdd_error(BDD_ILLBDD); + if (LOW(root) == -1) + return bdd_error(BDD_ILLBDD); + + INCREF(root); + return root; +} + + +/* +NAME {* bdd\_delref *} +SECTION {* kernel *} +SHORT {* decreases the reference count on a node *} +PROTO {* BDD bdd_delref(BDD r) *} +DESCR {* Reference counting is done on externaly referenced nodes only + and the count for a specific node {\tt r} can and must be + decreased using this function to make it possible to reclaim the + node in the next garbage collection. *} +ALSO {* bdd\_addref *} +RETURN {* The BDD node {\tt r}. *} +*/ +BDD bdd_delref(BDD root) +{ + if (root < 2 || !bddrunning) + return root; + if (root >= bddnodesize) + return bdd_error(BDD_ILLBDD); + if (LOW(root) == -1) + return bdd_error(BDD_ILLBDD); + + /* if the following line is present, fails there much earlier */ + if (!HASREF(root)) bdd_error(BDD_BREAK); /* distinctive */ + + DECREF(root); + return root; +} + + +/*=== RECURSIVE MARK / UNMARK ==========================================*/ + +void bdd_mark(int i) +{ + BddNode *node; + + if (i < 2) + return; + + node = &bddnodes[i]; + if (LEVELp(node) & MARKON || LOWp(node) == -1) + return; + + LEVELp(node) |= MARKON; + + bdd_mark(LOWp(node)); + bdd_mark(HIGHp(node)); +} + + +void bdd_mark_upto(int i, int level) +{ + BddNode *node = &bddnodes[i]; + + if (i < 2) + return; + + if (LEVELp(node) & MARKON || LOWp(node) == -1) + return; + + if (LEVELp(node) > level) + return; + + LEVELp(node) |= MARKON; + + bdd_mark_upto(LOWp(node), level); + bdd_mark_upto(HIGHp(node), level); +} + + +void bdd_markcount(int i, int *cou) +{ + BddNode *node; + + if (i < 2) + return; + + node = &bddnodes[i]; + if (MARKEDp(node) || LOWp(node) == -1) + return; + + SETMARKp(node); + *cou += 1; + + bdd_markcount(LOWp(node), cou); + bdd_markcount(HIGHp(node), cou); +} + + +void bdd_unmark(int i) +{ + BddNode *node; + + if (i < 2) + return; + + node = &bddnodes[i]; + + if (!MARKEDp(node) || LOWp(node) == -1) + return; + UNMARKp(node); + + bdd_unmark(LOWp(node)); + bdd_unmark(HIGHp(node)); +} + + +void bdd_unmark_upto(int i, int level) +{ + BddNode *node = &bddnodes[i]; + + if (i < 2) + return; + + if (!(LEVELp(node) & MARKON)) + return; + + LEVELp(node) &= MARKOFF; + + if (LEVELp(node) > level) + return; + + bdd_unmark_upto(LOWp(node), level); + bdd_unmark_upto(HIGHp(node), level); +} + + +/************************************************************************* + Unique node table functions +*************************************************************************/ + +int bdd_makenode(unsigned int level, int low, int high) +{ + register BddNode *node; + register unsigned int hash; + register int res; + +#ifdef CACHESTATS + bddcachestats.uniqueAccess++; +#endif + + /* check whether childs are equal */ + if (low == high) + return low; + + /* Try to find an existing node of this kind */ + hash = NODEHASH(level, low, high); + res = bddnodes[hash].hash; + + while(res != 0) + { + if (LEVEL(res) == level && LOW(res) == low && HIGH(res) == high) + { +#ifdef CACHESTATS + bddcachestats.uniqueHit++; +#endif + return res; + } + + res = bddnodes[res].next; +#ifdef CACHESTATS + bddcachestats.uniqueChain++; +#endif + } + + /* No existing node -> build one */ +#ifdef CACHESTATS + bddcachestats.uniqueMiss++; +#endif + + /* Any free nodes to use ? */ + if (bddfreepos == 0) + { + if (bdderrorcond) + return 0; + + /* Try to allocate more nodes */ + bdd_gbc(); + + if ((bddnodesize-bddfreenum) >= usednodes_nextreorder && + bdd_reorder_ready()) + { + longjmp(bddexception,1); + } + + if ((bddfreenum*100) / bddnodesize <= minfreenodes) + { + bdd_noderesize(1); + hash = NODEHASH(level, low, high); + } + + /* Panic if that is not possible */ + if (bddfreepos == 0) + { + bdd_error(BDD_NODENUM); + bdderrorcond = abs(BDD_NODENUM); + return 0; + } + } + + /* Build new node */ + res = bddfreepos; + bddfreepos = bddnodes[bddfreepos].next; + bddfreenum--; + bddproduced++; + + node = &bddnodes[res]; + LEVELp(node) = level; + LOWp(node) = low; + HIGHp(node) = high; + + /* Insert node */ + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = res; + + return res; +} + + +int bdd_noderesize(int doRehash) +{ + BddNode *newnodes; + int oldsize = bddnodesize; + int n; + + if (bddnodesize >= bddmaxnodesize && bddmaxnodesize > 0) + return -1; + + bddnodesize = bddnodesize << 1; + + if (bddnodesize > oldsize + bddmaxnodeincrease) + bddnodesize = oldsize + bddmaxnodeincrease; + + if (bddnodesize > bddmaxnodesize && bddmaxnodesize > 0) + bddnodesize = bddmaxnodesize; + + bddnodesize = bdd_prime_lte(bddnodesize); + + if (resize_handler != NULL) + resize_handler(oldsize, bddnodesize); + + newnodes = (BddNode*)realloc(bddnodes, sizeof(BddNode)*bddnodesize); + if (newnodes == NULL) + return bdd_error(BDD_MEMORY); + bddnodes = newnodes; + + if (doRehash) + for (n=0 ; n 1 ; n=HIGH(n)) + num++; + + if (((*varset) = (int *)malloc(sizeof(int)*num)) == NULL) + return bdd_error(BDD_MEMORY); + + for (n=r, num=0 ; n > 1 ; n=HIGH(n)) + (*varset)[num++] = bddlevel2var[LEVEL(n)]; + + *varnum = num; + + return 0; +} + + +/* +NAME {* bdd\_makeset *} +SECTION {* kernel *} +SHORT {* builds a BDD variable set from an integer array *} +PROTO {* BDD bdd_makeset(int *v, int n) *} +DESCR {* Reads a set of variable numbers from the integer array {\tt v} + which must hold exactly {\tt n} integers and then builds a BDD + representing the variable set. + + The BDD variable set is represented as the conjunction of + all the variables in their positive form and may just as + well be made that way by the user. The user should keep a + reference to the returned BDD instead of building it every + time the set is needed. *} +ALSO {* bdd\_scanset *} +RETURN {* A BDD variable set. *} */ +BDD bdd_makeset(int *varset, int varnum) +{ + int v, res=1; + + for (v=varnum-1 ; v>=0 ; v--) + { + BDD tmp; + bdd_addref(res); + tmp = bdd_apply(res, bdd_ithvar(varset[v]), bddop_and); + bdd_delref(res); + res = tmp; + } + + return res; +} + + +/* EOF */ + +/* int PUSHREF(int a) {return *(bddrefstacktop++) = (a);} */ diff --git a/sdk/buddy-2.4/src/kernel.h b/sdk/buddy-2.4/src/kernel.h new file mode 100644 index 0000000..03f3321 --- /dev/null +++ b/sdk/buddy-2.4/src/kernel.h @@ -0,0 +1,231 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/kernel.h,v 1.2 2004/07/13 20:51:49 haimcohen Exp $ + FILE: kernel.h + DESCR: Kernel specific definitions for BDD package + AUTH: Jorn Lind + DATE: (C) june 1997 +*************************************************************************/ + +#ifndef _KERNEL_H +#define _KERNEL_H + +/*=== Includes =========================================================*/ + +#include +#include +#include "bdd.h" + +/*=== SANITY CHECKS ====================================================*/ + + /* Make sure we use at least 32 bit integers */ +#if (INT_MAX < 0x7FFFFFFF) +#error The compiler does not support 4 byte integers! +#endif + + + /* Sanity check argument and return eventual error code */ +#define CHECK(r)\ + if (!bddrunning) return bdd_error(BDD_RUNNING);\ + else if ((r) < 0 || (r) >= bddnodesize) return bdd_error(BDD_ILLBDD);\ + else if (r >= 2 && LOW(r) == -1) return bdd_error(BDD_ILLBDD)\ + + /* Sanity check argument and return eventually the argument 'a' */ +#define CHECKa(r,a)\ + if (!bddrunning) { bdd_error(BDD_RUNNING); return (a); }\ + else if ((r) < 0 || (r) >= bddnodesize)\ + { bdd_error(BDD_ILLBDD); return (a); }\ + else if (r >= 2 && LOW(r) == -1)\ + { bdd_error(BDD_ILLBDD); return (a); } + +#define CHECKn(r)\ + if (!bddrunning) { bdd_error(BDD_RUNNING); return; }\ + else if ((r) < 0 || (r) >= bddnodesize)\ + { bdd_error(BDD_ILLBDD); return; }\ + else if (r >= 2 && LOW(r) == -1)\ + { bdd_error(BDD_ILLBDD); return; } + + +/*=== SEMI-INTERNAL TYPES ==============================================*/ + +typedef struct s_BddNode /* Node table entry */ +{ + unsigned int refcou : 10; + unsigned int level : 22; + int low; + int high; + int hash; + int next; +} BddNode; + + +/*=== KERNEL VARIABLES =================================================*/ + +#ifdef CPLUSPLUS +extern "C" { +#endif + +extern int bddrunning; /* Flag - package initialized */ +extern int bdderrorcond; /* Some error condition was met */ +extern int bddnodesize; /* Number of allocated nodes */ +extern int bddmaxnodesize; /* Maximum allowed number of nodes */ +extern int bddmaxnodeincrease; /* Max. # of nodes used to inc. table */ +extern BddNode* bddnodes; /* All of the bdd nodes */ +extern int bddvarnum; /* Number of defined BDD variables */ +extern int* bddrefstack; /* Internal node reference stack */ +extern int* bddrefstacktop; /* Internal node reference stack top */ +extern int* bddvar2level; +extern int* bddlevel2var; +extern jmp_buf bddexception; +extern int bddreorderdisabled; +extern int bddresized; +extern bddCacheStat bddcachestats; + +#ifdef CPLUSPLUS +} +#endif + + +/*=== KERNEL DEFINITIONS ===============================================*/ + +#define MAXVAR 0x1FFFFF +#define MAXREF 0x3FF + + /* Reference counting */ +#define DECREF(n) if (bddnodes[n].refcou!=MAXREF && bddnodes[n].refcou>0) bddnodes[n].refcou-- +#define INCREF(n) if (bddnodes[n].refcourefcou!=MAXREF && n->refcou>0) n->refcou-- +#define INCREFp(n) if (n->refcourefcou++ +#define HASREF(n) (bddnodes[n].refcou > 0) + + /* Marking BDD nodes */ +#define MARKON 0x200000 /* Bit used to mark a node (1) */ +#define MARKOFF 0x1FFFFF /* - unmark */ +#define MARKHIDE 0x1FFFFF +#define SETMARK(n) (bddnodes[n].level |= MARKON) +#define UNMARK(n) (bddnodes[n].level &= MARKOFF) +#define MARKED(n) (bddnodes[n].level & MARKON) +#define SETMARKp(p) (node->level |= MARKON) +#define UNMARKp(p) (node->level &= MARKOFF) +#define MARKEDp(p) (node->level & MARKON) + + /* Hashfunctions */ + +#define PAIR(a,b) ((unsigned int)((((unsigned int)a)+((unsigned int)b))*(((unsigned int)a)+((unsigned int)b)+((unsigned int)1))/((unsigned int)2)+((unsigned int)a))) +#define TRIPLE(a,b,c) ((unsigned int)(PAIR((unsigned int)c,PAIR(a,b)))) + + + /* Inspection of BDD nodes */ +#define ISCONST(a) ((a) < 2) +#define ISNONCONST(a) ((a) >= 2) +#define ISONE(a) ((a) == 1) +#define ISZERO(a) ((a) == 0) +#define LEVEL(a) (bddnodes[a].level) +#define LOW(a) (bddnodes[a].low) +#define HIGH(a) (bddnodes[a].high) +#define LEVELp(p) ((p)->level) +#define LOWp(p) ((p)->low) +#define HIGHp(p) ((p)->high) + + /* Stacking for garbage collector */ +#define INITREF (bddrefstacktop = bddrefstack) +#define PUSHREF(a) (*(bddrefstacktop++) = (a)) +/* int PUSHREF(int a); */ +#define READREF(a) (*(bddrefstacktop-(a))) +#define POPREF(a) (bddrefstacktop -= (a)) + +#define BDDONE 1 +#define BDDZERO 0 + +#ifndef CLOCKS_PER_SEC + /* Pass `CPPFLAGS=-DDEFAULT_CLOCK=1000' as an argument to ./configure + to override this setting. */ +# ifndef DEFAULT_CLOCK +# define DEFAULT_CLOCK 60 +# endif +# define CLOCKS_PER_SEC DEFAULT_CLOCK +#endif + +#define DEFAULTMAXNODEINC 50000 + +#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MAX(a,b) ((a) > (b) ? (a) : (b)) +#define NEW(t,n) ( (t*)malloc(sizeof(t)*(n)) ) + + +/*=== KERNEL PROTOTYPES ================================================*/ + +#ifdef CPLUSPLUS +extern "C" { +#endif + +extern int bdd_error(int); +extern int bdd_makenode(unsigned int, int, int); +extern int bdd_noderesize(int); +extern void bdd_checkreorder(void); +extern void bdd_mark(int); +extern void bdd_mark_upto(int, int); +extern void bdd_markcount(int, int*); +extern void bdd_unmark(int); +extern void bdd_unmark_upto(int, int); +extern void bdd_register_pair(bddPair*); +extern int *fdddec2bin(int, int); + +extern int bdd_operator_init(int); +extern void bdd_operator_done(void); +extern void bdd_operator_varresize(void); +extern void bdd_operator_reset(void); + +extern void bdd_pairs_init(void); +extern void bdd_pairs_done(void); +extern int bdd_pairs_resize(int,int); +extern void bdd_pairs_vardown(int); + +extern void bdd_fdd_init(void); +extern void bdd_fdd_done(void); + +extern void bdd_reorder_init(void); +extern void bdd_reorder_done(void); +extern int bdd_reorder_ready(void); +extern void bdd_reorder_auto(void); +extern int bdd_reorder_vardown(int); +extern int bdd_reorder_varup(int); + +extern void bdd_cpp_init(void); + +#ifdef CPLUSPLUS +} +#endif + +#endif /* _KERNEL_H */ + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/libbdd.la b/sdk/buddy-2.4/src/libbdd.la new file mode 100644 index 0000000..75c807d --- /dev/null +++ b/sdk/buddy-2.4/src/libbdd.la @@ -0,0 +1,35 @@ +# libbdd.la - a libtool library file +# Generated by ltmain.sh - GNU libtool 1.5.6 (1.1220.2.95 2004/04/11 05:50:42) +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='libbdd.so.0' + +# Names of this library. +library_names='libbdd.so.0.0.0 libbdd.so.0 libbdd.so' + +# The name of the static archive. +old_library='libbdd.a' + +# Libraries that this one depends upon. +dependency_libs='' + +# Version information for libbdd. +current=0 +age=0 +revision=0 + +# Is this an already installed library? +installed=no + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/usr/local/lib' diff --git a/sdk/buddy-2.4/src/pairs.c b/sdk/buddy-2.4/src/pairs.c new file mode 100644 index 0000000..c77a52b --- /dev/null +++ b/sdk/buddy-2.4/src/pairs.c @@ -0,0 +1,335 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/pairs.c,v 1.1.1.1 2004/06/25 13:22:50 haimcohen Exp $ + FILE: pairs.c + DESCR: Pair management for BDD package. + AUTH: Jorn Lind + DATE: february 1997 +*************************************************************************/ +#include +#include +#include "kernel.h" + +/*======================================================================*/ + +static int pairsid; /* Pair identifier */ +static bddPair* pairs; /* List of all replacement pairs in use */ + + +/************************************************************************* +*************************************************************************/ + +void bdd_pairs_init(void) +{ + pairsid = 0; + pairs = NULL; +} + + +void bdd_pairs_done(void) +{ + bddPair *p = pairs; + int n; + + while (p != NULL) + { + bddPair *next = p->next; + for (n=0 ; nresult[n] ); + free(p->result); + free(p); + p = next; + } +} + + +static int update_pairsid(void) +{ + pairsid++; + + if (pairsid == (INT_MAX >> 2)) + { + bddPair *p; + pairsid = 0; + for (p=pairs ; p!=NULL ; p=p->next) + p->id = pairsid++; + bdd_operator_reset(); + } + + return pairsid; +} + + +void bdd_register_pair(bddPair *p) +{ + p->next = pairs; + pairs = p; +} + + +void bdd_pairs_vardown(int level) +{ + bddPair *p; + + for (p=pairs ; p!=NULL ; p=p->next) + { + int tmp; + + tmp = p->result[level]; + p->result[level] = p->result[level+1]; + p->result[level+1] = tmp; + + if (p->last == level) + p->last++; + } +} + + +int bdd_pairs_resize(int oldsize, int newsize) +{ + bddPair *p; + int n; + + for (p=pairs ; p!=NULL ; p=p->next) + { + if ((p->result=(BDD*)realloc(p->result,sizeof(BDD)*newsize)) == NULL) + return bdd_error(BDD_MEMORY); + + for (n=oldsize ; nresult[n] = bdd_ithvar(bddlevel2var[n]); + } + + return 0; +} + + +/* +NAME {* bdd\_newpair *} +SECTION {* kernel *} +SHORT {* creates an empty variable pair table *} +PROTO {* bddPair *bdd_newpair(void) *} +DESCR {* Variable pairs of the type {\tt bddPair} are used in + {\tt bdd\_replace} to define which variables to replace with + other variables. This function allocates such an empty table. The + table can be freed by a call to {\em bdd\_freepair}. *} +RETURN {* Returns a new table of pairs. *} +ALSO {* bdd\_freepair, bdd\_replace, bdd\_setpair, bdd\_setpairs *} +*/ +bddPair *bdd_newpair(void) +{ + int n; + bddPair *p; + + if ((p=(bddPair*)malloc(sizeof(bddPair))) == NULL) + { + bdd_error(BDD_MEMORY); + return NULL; + } + + if ((p->result=(BDD*)malloc(sizeof(BDD)*bddvarnum)) == NULL) + { + free(p); + bdd_error(BDD_MEMORY); + return NULL; + } + + for (n=0 ; nresult[n] = bdd_ithvar(bddlevel2var[n]); + + p->id = update_pairsid(); + p->last = -1; + + bdd_register_pair(p); + return p; +} + + +/* +NAME {* bdd\_setpair *} +EXTRA {* bdd\_setbddpair *} +SECTION {* kernel *} +SHORT {* set one variable pair *} +PROTO {* int bdd_setpair(bddPair *pair, int oldvar, int newvar) +int bdd_setbddpair(bddPair *pair, BDD oldvar, BDD newvar) *} +DESCR {* Adds the pair {\tt (oldvar,newvar)} to the table of pairs + {\tt pair}. This results in {\tt oldvar} being substituted + with {\tt newvar} in a call to {\tt bdd\_replace}. In the first + version {\tt newvar} is an integer representing the variable + to be replaced with the old variable. + In the second version {\tt oldvar} is a BDD. + In this case the variable {\tt oldvar} is substituted with the + BDD {\tt newvar}. + The possibility to substitute with any BDD as {\tt newvar} is + utilized in bdd\_compose, whereas only the topmost variable + in the BDD is used in bdd\_replace. *} +RETURN {* Zero on success, otherwise a negative error code. *} +ALSO {* bdd\_newpair, bdd\_setpairs, bdd\_resetpair, bdd\_replace, bdd\_compose *} +*/ +int bdd_setpair(bddPair *pair, int oldvar, int newvar) +{ + if (pair == NULL) + return 0; + + if (oldvar < 0 || oldvar > bddvarnum-1) + return bdd_error(BDD_VAR); + if (newvar < 0 || newvar > bddvarnum-1) + return bdd_error(BDD_VAR); + + bdd_delref( pair->result[bddvar2level[oldvar]] ); + pair->result[bddvar2level[oldvar]] = bdd_ithvar(newvar); + pair->id = update_pairsid(); + + if (bddvar2level[oldvar] > pair->last) + pair->last = bddvar2level[oldvar]; + + return 0; +} + + +int bdd_setbddpair(bddPair *pair, int oldvar, BDD newvar) +{ + int oldlevel; + + if (pair == NULL) + return 0; + + CHECK(newvar); + if (oldvar < 0 || oldvar >= bddvarnum) + return bdd_error(BDD_VAR); + oldlevel = bddvar2level[oldvar]; + + bdd_delref( pair->result[oldlevel] ); + pair->result[oldlevel] = bdd_addref(newvar); + pair->id = update_pairsid(); + + if (oldlevel > pair->last) + pair->last = oldlevel; + + return 0; +} + + +/* +NAME {* bdd\_setpairs *} +EXTRA {* bdd\_setbddpairs *} +SECTION {* kernel *} +SHORT {* defines a whole set of pairs *} +PROTO {* int bdd_setpairs(bddPair *pair, int *oldvar, int *newvar, int size) +int bdd_setbddpairs(bddPair *pair, int *oldvar, BDD *newvar, int size) *} +DESCR {* As for {\tt bdd\_setpair} but with {\tt oldvar} and {\tt newvar} + being arrays of variables (BDDs) of size {\tt size}. *} +RETURN {* Zero on success, otherwise a negative error code. *} +ALSO {* bdd\_newpair, bdd\_setpair, bdd\_replace, bdd\_compose *} +*/ +int bdd_setpairs(bddPair *pair, int *oldvar, int *newvar, int size) +{ + int n,e; + if (pair == NULL) + return 0; + + for (n=0 ; nnext != p) + bp = bp->next; + + if (bp != NULL) + bp->next = p->next; + } + else + pairs = p->next; + + for (n=0 ; nresult[n] ); + free(p->result); + free(p); +} + + +/* +NAME {* bdd\_resetpair *} +SECTION {* kernel *} +SHORT {* clear all variable pairs *} +PROTO {* void bdd_resetpair(bddPair *pair) *} +DESCR {* Resets the table of pairs {\tt pair} by setting all substitutions + to their default values (that is no change). *} +ALSO {* bdd\_newpair, bdd\_setpair, bdd\_freepair *} +*/ +void bdd_resetpair(bddPair *p) +{ + int n; + + for (n=0 ; nresult[n] = bdd_ithvar(n); + p->last = 0; +} + + +/* EOF */ + diff --git a/sdk/buddy-2.4/src/prime.c b/sdk/buddy-2.4/src/prime.c new file mode 100644 index 0000000..13c9ac6 --- /dev/null +++ b/sdk/buddy-2.4/src/prime.c @@ -0,0 +1,321 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/prime.c,v 1.1.1.1 2004/06/25 13:22:51 haimcohen Exp $ + FILE: prime.c + DESCR: Prime number calculations + AUTH: Jorn Lind + DATE: (C) feb 2001 +*************************************************************************/ +#include +#include +#include +#include "prime.h" + + +#define Random(i) ( (rand() % (i)) + 1 ) +#define isEven(src) (!((src) & 0x1)) +#define hasFactor(src,n) ( (((src)!=(n)) && ((src)%(n) == 0)) ) +#define BitIsSet(src,b) ( ((src) & (1<<(b))) != 0 ) + +#define CHECKTIMES 20 + +#if defined(BUDDYUINT64) + typedef BUDDYUINT64 UINT64; + #define BUILTIN64 +#elif defined(__GNUC__) || defined(__KCC) + typedef long long UINT64; + #define BUILTIN64 +#elif defined(_MSV_VER) + typedef unsigned _int64 UINT64; + #define BUILTIN64 +#else + typedef struct __UINT64 + { + unsigned int hi; + unsigned int lo; + } UINT64; + + #define MAX(a,b) ((a) > (b) ? (a) : (b)) + #define GETCARRY(a,b) ( ((a)+(b)) < MAX((a),(b)) ? 1 : 0 ) +#endif + + +#ifndef BUILTIN64 +/************************************************************************* + 64 bit unsigned int arithmetics +*************************************************************************/ + +static UINT64 u64_mul(unsigned int x, unsigned int y) +{ + UINT64 res; + unsigned int yh = 0; + unsigned int yl = y; + int i; + + res.lo = res.hi = 0; + + for (i=0 ; i<32 ; ++i) + { + if (x & 0x1) + { + unsigned int carry = GETCARRY(res.lo,yl); + res.lo += yl; + res.hi += yh + carry; + } + + yh = (yh << 1) | (yl & 0x80000000 ? 1 : 0); + yl = (yl << 1); + + x >>= 1; + } + + return res; +} + + +static void u64_shl(UINT64* a, unsigned int *carryOut) +{ + *carryOut = (*carryOut << 1) | (a->hi & 0x80000000 ? 0x1 : 0x0); + a->hi = (a->hi << 1) | (a->lo & 0x80000000 ? 0x1 : 0x0); + a->lo = (a->lo << 1); +} + + +static unsigned int u64_mod(UINT64 dividend, unsigned int divisor) +{ + unsigned int remainder = 0; + int i; + + u64_shl(÷nd, &remainder); + + for (i=0 ; i<64 ; ++i) + { + if (remainder >= divisor) + remainder -= divisor; + + u64_shl(÷nd, &remainder); + } + + return remainder >> 1; +} +#endif /* BUILTIN64 */ + +#ifdef BUILTIN64 +#define u64_mulmod(a,b,c) ((unsigned int)( ((UINT64)a*(UINT64)b)%(UINT64)c )); +#else +#define u64_mulmod(a,b,c) u64_mod( u64_mul((a),(b)), (c) ); +#endif + + +/************************************************************************* + Miller Rabin check +*************************************************************************/ + +static unsigned int numberOfBits(unsigned int src) +{ + unsigned int b; + + if (src == 0) + return 0; + + for (b=(sizeof(unsigned int)*8)-1 ; b>0 ; --b) + if (BitIsSet(src,b)) + return b+1; + + return 1; +} + + + +static int isWitness(unsigned int witness, unsigned int src) +{ + unsigned int bitNum = numberOfBits(src-1)-1; + unsigned int d = 1; + int i; + + for (i=bitNum ; i>=0 ; --i) + { + unsigned int x = d; + + d = u64_mulmod(d,d,src); + + if (d == 1 && x != 1 && x != src-1) + return 1; + + if (BitIsSet(src-1,i)) + d = u64_mulmod(d,witness,src); + } + + return d != 1; +} + + +static int isMillerRabinPrime(unsigned int src) +{ + int n; + + for (n=0 ; n +#include +#include +#include +#include +#include "kernel.h" +#include "bddtree.h" +#include "imatrix.h" +#include "prime.h" + +/* IMPORTANT: + * The semantics of the "level" field in the BddNode struct changes during + * variable reordering in order to make a fast variable swap possible when + * two variables are independent. Instead of refering to the level of the node + * it refers to the *variable* !!! + */ + + /* Change macros to reflect the above idea */ +#define VAR(n) (bddnodes[n].level) +#define VARp(p) (p->level) + + /* Avoid these - they are misleading! */ +#undef LEVEL +#undef LEVELp + + +#define __USERESIZE /* FIXME */ + + /* Current auto reord. method and number of automatic reorderings left */ +static int bddreordermethod; +static int bddreordertimes; + + /* Flag for disabling reordering temporarily */ +static int reorderdisabled; + + /* Store for the variable relationships */ +static BddTree *vartree; +static int blockid; + + /* Store for the ref.cou. of the external roots */ +static int *extroots; +static int extrootsize; + +/* Level data */ +typedef struct _levelData +{ + int start; /* Start of this sub-table (entry in "bddnodes") */ + int size; /* Size of this sub-table */ + int maxsize; /* Max. allowed size of sub-table */ + int nodenum; /* Number of nodes in this level */ +} levelData; + +static levelData *levels; /* Indexed by variable! */ + + /* Interaction matrix */ +static imatrix *iactmtx; + + /* Reordering information for the user */ +static int verbose; +static bddinthandler reorder_handler; +static bddfilehandler reorder_filehandler; +static bddsizehandler reorder_nodenum; + + /* Number of live nodes before and after a reordering session */ +static int usednum_before; +static int usednum_after; + + /* Kernel variables needed for reordering */ +extern int bddfreepos; +extern int bddfreenum; +extern int bddproduced; + + /* Flag telling us when a node table resize is done */ +static int resizedInMakenode; + + /* New node hashing function for use with reordering */ +#define NODEHASH(var,l,h) ((PAIR((l),(h))%levels[var].size)+levels[var].start) + + /* Reordering prototypes */ +static void blockdown(BddTree *); +static void addref_rec(int, char *); +static void reorder_gbc(); +static void reorder_setLevellookup(void); +static int reorder_makenode(int, int, int); +static int reorder_varup(int); +static int reorder_vardown(int); +static int reorder_init(void); +static void reorder_done(void); + +#define random(a) (rand() % (a)) + + /* For sorting the blocks according to some specific size value */ +typedef struct s_sizePair +{ + int val; + BddTree *block; +} sizePair; + + +/************************************************************************* + Initialize and shutdown +*************************************************************************/ + +void bdd_reorder_init(void) +{ + reorderdisabled = 0; + vartree = NULL; + + bdd_clrvarblocks(); + bdd_reorder_hook(bdd_default_reohandler); + bdd_reorder_verbose(0); + bdd_autoreorder_times(BDD_REORDER_NONE, 0); + reorder_nodenum = bdd_getnodenum; + usednum_before = usednum_after = 0; + blockid = 0; +} + + +void bdd_reorder_done(void) +{ + bddtree_del(vartree); + bdd_operator_reset(); + vartree = NULL; +} + + +/************************************************************************* + Reordering heuristics +*************************************************************************/ + +/*=== Reorder using a sliding window of size 2 =========================*/ + +static BddTree *reorder_win2(BddTree *t) +{ + BddTree *this=t, *first=t; + + if (t == NULL) + return t; + + if (verbose > 1) + printf("Win2 start: %d nodes\n", reorder_nodenum()); + fflush(stdout); + + while (this->next != NULL) + { + int best = reorder_nodenum(); + blockdown(this); + + if (best < reorder_nodenum()) + { + blockdown(this->prev); + this = this->next; + } + else + if (first == this) + first = this->prev; + + if (verbose > 1) + { + printf("."); + fflush(stdout); + } + } + + if (verbose > 1) + printf("\nWin2 end: %d nodes\n", reorder_nodenum()); + fflush(stdout); + + return first; +} + + +static BddTree *reorder_win2ite(BddTree *t) +{ + BddTree *this, *first=t; + int lastsize; + int c=1; + + if (t == NULL) + return t; + + if (verbose > 1) + printf("Win2ite start: %d nodes\n", reorder_nodenum()); + + do + { + lastsize = reorder_nodenum(); + + this = t; + while (this->next != NULL) + { + int best = reorder_nodenum(); + + blockdown(this); + + if (best < reorder_nodenum()) + { + blockdown(this->prev); + this = this->next; + } + else + if (first == this) + first = this->prev; + if (verbose > 1) + { + printf("."); + fflush(stdout); + } + } + + if (verbose > 1) + printf(" %d nodes\n", reorder_nodenum()); + c++; + } + while (reorder_nodenum() != lastsize); + + return first; +} + + +/*=== Reorder using a sliding window of size 3 =========================*/ +#define X(a) + +static BddTree *reorder_swapwin3(BddTree *this, BddTree **first) +{ + int setfirst = (this->prev == NULL ? 1 : 0); + BddTree *next = this; + int best = reorder_nodenum(); + + if (this->next->next == NULL) /* Only two blocks left -> win2 swap */ + { + blockdown(this); + + if (best < reorder_nodenum()) + { + blockdown(this->prev); + next = this->next; + } + else + { + next = this; + if (setfirst) + *first = this->prev; + } + } + else /* Real win3 swap */ + { + int pos = 0; + X(printf("%d: ", reorder_nodenum())); + blockdown(this); /* B A* C (4) */ + X(printf("A")); + pos++; + if (best > reorder_nodenum()) + { + X(printf("(%d)", reorder_nodenum())); + pos = 0; + best = reorder_nodenum(); + } + + blockdown(this); /* B C A* (3) */ + X(printf("B")); + pos++; + if (best > reorder_nodenum()) + { + X(printf("(%d)", reorder_nodenum())); + pos = 0; + best = reorder_nodenum(); + } + + this = this->prev->prev; + blockdown(this); /* C B* A (2) */ + X(printf("C")); + pos++; + if (best > reorder_nodenum()) + { + X(printf("(%d)", reorder_nodenum())); + pos = 0; + best = reorder_nodenum(); + } + + blockdown(this); /* C A B* (1) */ + X(printf("D")); + pos++; + if (best > reorder_nodenum()) + { + X(printf("(%d)", reorder_nodenum())); + pos = 0; + best = reorder_nodenum(); + } + + this = this->prev->prev; + blockdown(this); /* A C* B (0)*/ + X(printf("E")); + pos++; + if (best > reorder_nodenum()) + { + X(printf("(%d)", reorder_nodenum())); + pos = 0; + best = reorder_nodenum(); + } + + X(printf(" -> ")); + + if (pos >= 1) /* A C B -> C A* B */ + { + this = this->prev; + blockdown(this); + next = this; + if (setfirst) + *first = this->prev; + X(printf("a(%d)", reorder_nodenum())); + } + + if (pos >= 2) /* C A B -> C B A* */ + { + blockdown(this); + next = this->prev; + if (setfirst) + *first = this->prev->prev; + X(printf("b(%d)", reorder_nodenum())); + } + + if (pos >= 3) /* C B A -> B C* A */ + { + this = this->prev->prev; + blockdown(this); + next = this; + if (setfirst) + *first = this->prev; + X(printf("c(%d)", reorder_nodenum())); + } + + if (pos >= 4) /* B C A -> B A C* */ + { + blockdown(this); + next = this->prev; + if (setfirst) + *first = this->prev->prev; + X(printf("d(%d)", reorder_nodenum())); + } + + if (pos >= 5) /* B A C -> A B* C */ + { + this = this->prev->prev; + blockdown(this); + next = this; + if (setfirst) + *first = this->prev; + X(printf("e(%d)", reorder_nodenum())); + } + X(printf("\n")); + } + + return next; +} + + +static BddTree *reorder_win3(BddTree *t) +{ + BddTree *this=t, *first=t; + + if (t == NULL) + return t; + + if (verbose > 1) + printf("Win3 start: %d nodes\n", reorder_nodenum()); + fflush(stdout); + + while (this->next != NULL) + { + this = reorder_swapwin3(this, &first); + + if (verbose > 1) + { + printf("."); + fflush(stdout); + } + } + + if (verbose > 1) + printf("\nWin3 end: %d nodes\n", reorder_nodenum()); + fflush(stdout); + + return first; +} + + +static BddTree *reorder_win3ite(BddTree *t) +{ + BddTree *this=t, *first=t; + int lastsize; + + if (t == NULL) + return t; + + if (verbose > 1) + printf("Win3ite start: %d nodes\n", reorder_nodenum()); + + do + { + lastsize = reorder_nodenum(); + this = first; + + while (this->next != NULL && this->next->next != NULL) + { + this = reorder_swapwin3(this, &first); + + if (verbose > 1) + { + printf("."); + fflush(stdout); + } + } + + if (verbose > 1) + printf(" %d nodes\n", reorder_nodenum()); + } + while (reorder_nodenum() != lastsize); + + if (verbose > 1) + printf("Win3ite end: %d nodes\n", reorder_nodenum()); + + return first; +} + + +/*=== Reorder by sifting =============================================*/ + +/* Move a specific block up and down in the order and place at last in + the best position +*/ +static void reorder_sift_bestpos(BddTree *blk, int middlePos) +{ + int best = reorder_nodenum(); + int maxAllowed; + int bestpos = 0; + int dirIsUp = 1; + int n; + + if (bddmaxnodesize > 0) + maxAllowed = MIN(best/5+best, bddmaxnodesize-bddmaxnodeincrease-2); + else + maxAllowed = best/5+best; + + /* Determine initial direction */ + if (blk->pos > middlePos) + dirIsUp = 0; + + /* Move block back and forth */ + for (n=0 ; n<2 ; n++) + { + int first = 1; + + if (dirIsUp) + { + while (blk->prev != NULL && + (reorder_nodenum() <= maxAllowed || first)) + { + first = 0; + blockdown(blk->prev); + bestpos--; + + if (verbose > 1) + { + printf("-"); + fflush(stdout); + } + + if (reorder_nodenum() < best) + { + best = reorder_nodenum(); + bestpos = 0; + + if (bddmaxnodesize > 0) + maxAllowed = MIN(best/5+best, + bddmaxnodesize-bddmaxnodeincrease-2); + else + maxAllowed = best/5+best; + } + } + } + else + { + while (blk->next != NULL && + (reorder_nodenum() <= maxAllowed || first)) + { + first = 0; + blockdown(blk); + bestpos++; + + if (verbose > 1) + { + printf("+"); + fflush(stdout); + } + + if (reorder_nodenum() < best) + { + best = reorder_nodenum(); + bestpos = 0; + + if (bddmaxnodesize > 0) + maxAllowed = MIN(best/5+best, + bddmaxnodesize-bddmaxnodeincrease-2); + else + maxAllowed = best/5+best; + } + } + } + + if (reorder_nodenum() > maxAllowed && verbose > 1) + { + printf("!"); + fflush(stdout); + } + + dirIsUp = !dirIsUp; + } + + /* Move to best pos */ + while (bestpos < 0) + { + blockdown(blk); + bestpos++; + } + while (bestpos > 0) + { + blockdown(blk->prev); + bestpos--; + } +} + + +/* Go through all blocks in a specific sequence and find best + position for each of them +*/ +static BddTree *reorder_sift_seq(BddTree *t, BddTree **seq, int num) +{ + BddTree *this; + int n; + + if (t == NULL) + return t; + + for (n=0 ; n 1) + { + printf("Sift "); + if (reorder_filehandler) + reorder_filehandler(stdout, seq[n]->id); + else + printf("%d", seq[n]->id); + printf(": "); + } + + reorder_sift_bestpos(seq[n], num/2); + + if (verbose > 1) + printf("\n> %d nodes", reorder_nodenum()); + + c2 = clock(); + if (verbose > 1) + printf(" (%.1f sec)\n", (float)(c2-c1)/CLOCKS_PER_SEC); + } + + /* Find first block */ + for (this=t ; this->prev != NULL ; this=this->prev) + /* nil */; + + return this; +} + + +/* Compare function for sorting sifting sequence + */ +static int siftTestCmp(const void *aa, const void *bb) +{ + const sizePair *a = (sizePair*)aa; + const sizePair *b = (sizePair*)bb; + + if (a->val < b->val) + return -1; + if (a->val > b->val) + return 1; + return 0; +} + + +/* Find sifting sequence based on the number of nodes at each level + */ +static BddTree *reorder_sift(BddTree *t) +{ + BddTree *this, **seq; + sizePair *p; + int n, num; + + for (this=t,num=0 ; this!=NULL ; this=this->next) + this->pos = num++; + + if ((p=NEW(sizePair,num)) == NULL) + return t; + if ((seq=NEW(BddTree*,num)) == NULL) + { + free(p); + return t; + } + + for (this=t,n=0 ; this!=NULL ; this=this->next,n++) + { + int v; + + /* Accumulate number of nodes for each block */ + p[n].val = 0; + for (v=this->first ; v<=this->last ; v++) + p[n].val -= levels[v].nodenum; + + p[n].block = this; + } + + /* Sort according to the number of nodes at each level */ + qsort(p, num, sizeof(sizePair), siftTestCmp); + + /* Create sequence */ + for (n=0 ; n 1) + printf("Reorder %d\n", c++); + + lastsize = reorder_nodenum(); + first = reorder_sift(first); + } + while (reorder_nodenum() != lastsize); + + return first; +} + + +/*=== Random reordering (mostly for debugging and test ) =============*/ + +static BddTree *reorder_random(BddTree *t) +{ + BddTree *this; + BddTree **seq; + int n, num=0; + + if (t == NULL) + return t; + + for (this=t ; this!=NULL ; this=this->next) + num++; + seq = NEW(BddTree*,num); + for (this=t,num=0 ; this!=NULL ; this=this->next) + seq[num++] = this; + + for (n=0 ; n<4*num ; n++) + { + int blk = random(num); + if (seq[blk]->next != NULL) + blockdown(seq[blk]); + } + + /* Find first block */ + for (this=t ; this->prev != NULL ; this=this->prev) + /* nil */; + + free(seq); + + if (verbose) + printf("Random order: %d nodes\n", reorder_nodenum()); + return this; +} + + +/************************************************************************* + Swapping adjacent blocks +*************************************************************************/ + +static void blockdown(BddTree *left) +{ + BddTree *right = left->next; + int n; + int leftsize = left->last - left->first; + int rightsize = right->last - right->first; + int leftstart = bddvar2level[left->seq[0]]; + int *lseq = left->seq; + int *rseq = right->seq; + + /* Move left past right */ + while (bddvar2level[lseq[0]] < bddvar2level[rseq[rightsize]]) + { + for (n=0 ; n leftstart) + { + for (n=rightsize ; n>0 ; n--) + { + if (bddvar2level[rseq[n]]-1 != bddvar2level[rseq[n-1]] + && bddvar2level[rseq[n]] > leftstart) + { + reorder_varup(rseq[n]); + } + } + + if (bddvar2level[rseq[0]] > leftstart) + reorder_varup(rseq[0]); + } + + /* Swap left and right data in the order */ + left->next = right->next; + right->prev = left->prev; + left->prev = right; + right->next = left; + + if (right->prev != NULL) + right->prev->next = right; + if (left->next != NULL) + left->next->prev = left; + + n = left->pos; + left->pos = right->pos; + right->pos = n; +} + + +/************************************************************************* + Kernel reordering routines +*************************************************************************/ + +/*=== Garbage collection for reordering ================================*/ + +/* Note: Node may be marked + */ +static void addref_rec(int r, char *dep) +{ + if (r < 2) + return; + + if (bddnodes[r].refcou == 0) + { + bddfreenum--; + + /* Detect variable dependencies for the interaction matrix */ + dep[VAR(r) & MARKHIDE] = 1; + + /* Make sure the nodenum field is updated. Used in the initial GBC */ + levels[VAR(r) & MARKHIDE].nodenum++; + + addref_rec(LOW(r), dep); + addref_rec(HIGH(r), dep); + } + else + { + int n; + + /* Update (from previously found) variable dependencies + * for the interaction matrix */ + for (n=0 ; n 0) + { + SETMARK(n); + extrootsize++; + } + } + + if ((extroots=(int*)(malloc(sizeof(int)*extrootsize))) == NULL) + return bdd_error(BDD_MEMORY); + + iactmtx = imatrixNew(bddvarnum); + + for (n=2,extrootsize=0 ; nhash = 0; + } + + bddnodes[0].hash = 0; + bddnodes[1].hash = 0; + + free(dep); + return 0; +} + + +/* Now that all nodes are recursively reference counted we must make sure + that the new hashing scheme is used AND that dead nodes are removed. + This is also a good time to create the interaction matrix. +*/ +static void reorder_gbc(void) +{ + int n; + + bddfreepos = 0; + bddfreenum = 0; + + /* No need to zero all hash fields - this is done in mark_roots */ + + for (n=bddnodesize-1 ; n>=2 ; n--) + { + register BddNode *node = &bddnodes[n]; + + if (node->refcou > 0) + { + register unsigned int hash; + + hash = NODEHASH(VARp(node), LOWp(node), HIGHp(node)); + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = n; + + } + else + { + LOWp(node) = -1; + node->next = bddfreepos; + bddfreepos = n; + bddfreenum++; + } + } +} + + +static void reorder_setLevellookup(void) +{ + int n; + + for (n=0 ; n= 4) + levels[n].size = bdd_prime_lte(levels[n].size); + +#if 0 + printf("L%3d: start %d, size %d, nodes %d\n", n, levels[n].start, + levels[n].size, levels[n].nodenum); +#endif + } +} + + +static void reorder_rehashAll(void) +{ + int n; + + reorder_setLevellookup(); + bddfreepos = 0; + + for (n=bddnodesize-1 ; n>=0 ; n--) + bddnodes[n].hash = 0; + + for (n=bddnodesize-1 ; n>=2 ; n--) + { + register BddNode *node = &bddnodes[n]; + + if (node->refcou > 0) + { + register unsigned int hash; + + hash = NODEHASH(VARp(node), LOWp(node), HIGHp(node)); + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = n; + } + else + { + node->next = bddfreepos; + bddfreepos = n; + } + } +} + + +/*=== Unique table handling for reordering =============================*/ + +/* Note: rehashing must not take place during a makenode call. It is okay + to resize the table, but *not* to rehash it. + */ +static int reorder_makenode(int var, int low, int high) +{ + register BddNode *node; + register unsigned int hash; + register int res; + +#ifdef CACHESTATS + bddcachestats.uniqueAccess++; +#endif + + /* Note: We know that low,high has a refcou greater than zero, so + there is no need to add reference *recursively* */ + + /* check whether childs are equal */ + if (low == high) + { + INCREF(low); + return low; + } + + /* Try to find an existing node of this kind */ + hash = NODEHASH(var, low, high); + res = bddnodes[hash].hash; + + while(res != 0) + { + if (LOW(res) == low && HIGH(res) == high) + { +#ifdef CACHESTATS + bddcachestats.uniqueHit++; +#endif + INCREF(res); + return res; + } + res = bddnodes[res].next; + +#ifdef CACHESTATS + bddcachestats.uniqueChain++; +#endif + } + + /* No existing node -> build one */ +#ifdef CACHESTATS + bddcachestats.uniqueMiss++; +#endif + + /* Any free nodes to use ? */ + if (bddfreepos == 0) + { + if (bdderrorcond) + return 0; + + /* Try to allocate more nodes - call noderesize without + * enabling rehashing. + * Note: if ever rehashing is allowed here, then remember to + * update local variable "hash" */ + bdd_noderesize(0); + resizedInMakenode = 1; + + /* Panic if that is not possible */ + if (bddfreepos == 0) + { + bdd_error(BDD_NODENUM); + bdderrorcond = abs(BDD_NODENUM); + return 0; + } + } + + /* Build new node */ + res = bddfreepos; + bddfreepos = bddnodes[bddfreepos].next; + levels[var].nodenum++; + bddproduced++; + bddfreenum--; + + node = &bddnodes[res]; + VARp(node) = var; + LOWp(node) = low; + HIGHp(node) = high; + + /* Insert node in hash chain */ + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = res; + + /* Make sure it is reference counted */ + node->refcou = 1; + INCREF(LOWp(node)); + INCREF(HIGHp(node)); + + return res; +} + + +/*=== Swapping two adjacent variables ==================================*/ + +/* Go through var 0 nodes. Move nodes that depends on var 1 to a separate + * chain (toBeProcessed) and let the rest stay in the table. + */ +static int reorder_downSimple(int var0) +{ + int toBeProcessed = 0; + int var1 = bddlevel2var[bddvar2level[var0]+1]; + int vl0 = levels[var0].start; + int size0 = levels[var0].size; + int n; + + levels[var0].nodenum = 0; + + for (n=0 ; nnext; + + if (VAR(LOWp(node)) != var1 && VAR(HIGHp(node)) != var1) + { + /* Node does not depend on next var, let it stay in the chain */ + node->next = bddnodes[n+vl0].hash; + bddnodes[n+vl0].hash = r; + levels[var0].nodenum++; + } + else + { + /* Node depends on next var - save it for later procesing */ + node->next = toBeProcessed; + toBeProcessed = r; +#ifdef SWAPCOUNT + bddcachestats.swapCount++; +#endif + + } + + r = next; + } + } + + return toBeProcessed; +} + + +/* Now process all the var 0 nodes that depends on var 1. + * + * It is extremely important that no rehashing is done inside the makenode + * calls, since this would destroy the toBeProcessed chain. + */ +static void reorder_swap(int toBeProcessed, int var0) +{ + int var1 = bddlevel2var[bddvar2level[var0]+1]; + + while (toBeProcessed) + { + BddNode *node = &bddnodes[toBeProcessed]; + int next = node->next; + int f0 = LOWp(node); + int f1 = HIGHp(node); + int f00, f01, f10, f11, hash; + + /* Find the cofactors for the new nodes */ + if (VAR(f0) == var1) + { + f00 = LOW(f0); + f01 = HIGH(f0); + } + else + f00 = f01 = f0; + + if (VAR(f1) == var1) + { + f10 = LOW(f1); + f11 = HIGH(f1); + } + else + f10 = f11 = f1; + + /* Note: makenode does refcou. */ + f0 = reorder_makenode(var0, f00, f10); + f1 = reorder_makenode(var0, f01, f11); + node = &bddnodes[toBeProcessed]; /* Might change in makenode */ + + /* We know that the refcou of the grandchilds of this node + * is greater than one (these are f00...f11), so there is + * no need to do a recursive refcou decrease. It is also + * possible for the LOWp(node)/high nodes to come alive again, + * so deref. of the childs is delayed until the local GBC. */ + + DECREF(LOWp(node)); + DECREF(HIGHp(node)); + + /* Update in-place */ + VARp(node) = var1; + LOWp(node) = f0; + HIGHp(node) = f1; + + levels[var1].nodenum++; + + /* Rehash the node since it got new childs */ + hash = NODEHASH(VARp(node), LOWp(node), HIGHp(node)); + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = toBeProcessed; + + toBeProcessed = next; + } +} + + +/* Now go through the var 1 chains. The nodes live here have survived + * the call to reorder_swap() and may stay in the chain. + * The dead nodes are reclaimed. + */ +static void reorder_localGbc(int var0) +{ + int var1 = bddlevel2var[bddvar2level[var0]+1]; + int vl1 = levels[var1].start; + int size1 = levels[var1].size; + int n; + + for (n=0 ; nnext; + + if (node->refcou > 0) + { + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = r; + } + else + { + DECREF(LOWp(node)); + DECREF(HIGHp(node)); + + LOWp(node) = -1; + node->next = bddfreepos; + bddfreepos = r; + levels[var1].nodenum--; + bddfreenum++; + } + + r = next; + } + } +} + + + + +#ifdef USERESIZE + +static void reorder_swapResize(int toBeProcessed, int var0) +{ + int var1 = bddlevel2var[bddvar2level[var0]+1]; + + while (toBeProcessed) + { + BddNode *node = &bddnodes[toBeProcessed]; + int next = node->next; + int f0 = LOWp(node); + int f1 = HIGHp(node); + int f00, f01, f10, f11; + + /* Find the cofactors for the new nodes */ + if (VAR(f0) == var1) + { + f00 = LOW(f0); + f01 = HIGH(f0); + } + else + f00 = f01 = f0; + + if (VAR(f1) == var1) + { + f10 = LOW(f1); + f11 = HIGH(f1); + } + else + f10 = f11 = f1; + + /* Note: makenode does refcou. */ + f0 = reorder_makenode(var0, f00, f10); + f1 = reorder_makenode(var0, f01, f11); + node = &bddnodes[toBeProcessed]; /* Might change in makenode */ + + /* We know that the refcou of the grandchilds of this node + * is greater than one (these are f00...f11), so there is + * no need to do a recursive refcou decrease. It is also + * possible for the LOWp(node)/high nodes to come alive again, + * so deref. of the childs is delayed until the local GBC. */ + + DECREF(LOWp(node)); + DECREF(HIGHp(node)); + + /* Update in-place */ + VARp(node) = var1; + LOWp(node) = f0; + HIGHp(node) = f1; + + levels[var1].nodenum++; + + /* Do not rehash yet since we are going to resize the hash table */ + + toBeProcessed = next; + } +} + + +static void reorder_localGbcResize(int toBeProcessed, int var0) +{ + int var1 = bddlevel2var[bddvar2level[var0]+1]; + int vl1 = levels[var1].start; + int size1 = levels[var1].size; + int n; + + for (n=0 ; nnext; + + if (node->refcou > 0) + { + node->next = toBeProcessed; + toBeProcessed = r; + } + else + { + DECREF(LOWp(node)); + DECREF(HIGHp(node)); + + LOWp(node) = -1; + node->next = bddfreepos; + bddfreepos = r; + levels[var1].nodenum--; + bddfreenum++; + } + + r = next; + } + } + + /* Resize */ + if (levels[var1].nodenum < levels[var1].size) + levels[var1].size = MIN(levels[var1].maxsize, levels[var1].size/2); + else + levels[var1].size = MIN(levels[var1].maxsize, levels[var1].size*2); + + if (levels[var1].size >= 4) + levels[var1].size = bdd_prime_lte(levels[var1].size); + + /* Rehash the remaining live nodes */ + while (toBeProcessed) + { + BddNode *node = &bddnodes[toBeProcessed]; + int next = node->next; + int hash = NODEHASH(VARp(node), LOWp(node), HIGHp(node)); + + node->next = bddnodes[hash].hash; + bddnodes[hash].hash = toBeProcessed; + + toBeProcessed = next; + } +} + +#endif /* USERESIZE */ + + +static int reorder_varup(int var) +{ + if (var < 0 || var >= bddvarnum) + return bdd_error(BDD_VAR); + if (bddvar2level[var] == 0) + return 0; + return reorder_vardown( bddlevel2var[bddvar2level[var]-1]); +} + + +#if 0 +static void sanitycheck(void) +{ + int n,v,r; + int cou=0; + + for (v=0 ; v 0) + { + assert(LEVEL(n) < LEVEL(LOW(n))); + assert(LEVEL(n) < LEVEL(HIGH(n))); + cou--; + } + } + + assert(cou == 0); +} +#endif + +static int reorder_vardown(int var) +{ + int n, level; + + if (var < 0 || var >= bddvarnum) + return bdd_error(BDD_VAR); + if ((level=bddvar2level[var]) >= bddvarnum-1) + return 0; + + resizedInMakenode = 0; + + if (imatrixDepends(iactmtx, var, bddlevel2var[level+1])) + { + int toBeProcessed = reorder_downSimple(var); +#ifdef USERESIZE + levelData *l = &levels[var]; + + if (l->nodenum < (l->size)/3 || + l->nodenum >= (l->size*3)/2 && l->size < l->maxsize) + { + reorder_swapResize(toBeProcessed, var); + reorder_localGbcResize(toBeProcessed, var); + } + else +#endif + { + reorder_swap(toBeProcessed, var); + reorder_localGbc(var); + } + } + + /* Swap the var<->level tables */ + n = bddlevel2var[level]; + bddlevel2var[level] = bddlevel2var[level+1]; + bddlevel2var[level+1] = n; + + n = bddvar2level[var]; + bddvar2level[var] = bddvar2level[ bddlevel2var[level] ]; + bddvar2level[ bddlevel2var[level] ] = n; + + /* Update all rename pairs */ + bdd_pairs_vardown(level); + + if (resizedInMakenode) + reorder_rehashAll(); + + return 0; +} + + +/************************************************************************* + User reordering interface +*************************************************************************/ + +/* +NAME {* bdd\_swapvar *} +SECTION {* reorder *} +SHORT {* Swap two BDD variables *} +PROTO {* int bdd_swapvar(int v1, int v2) *} +DESCR {* Use {\tt bdd\_swapvar} to swap the position (in the current + variable order) of the two BDD + variables {\tt v1} and {\tt v2}. There are no constraints on the + position of the two variables before the call. This function may + {\em not} be used together with user defined variable blocks. + The swap is done by a series of adjacent variable swaps and + requires the whole node table to be rehashed twice for each call + to {\tt bdd\_swapvar}. It should therefore not be used were + efficiency is a major concern. *} +RETURN {* Zero on succes and a negative error code otherwise. *} +ALSO {* bdd\_reorder, bdd\_addvarblock *} +*/ +int bdd_swapvar(int v1, int v2) +{ + int l1, l2; + + /* Do not swap when variable-blocks are used */ + if (vartree != NULL) + return bdd_error(BDD_VARBLK); + + /* Don't bother swapping x with x */ + if (v1 == v2) + return 0; + + /* Make sure the variable exists */ + if (v1 < 0 || v1 >= bddvarnum || v2 < 0 || v2 >= bddvarnum) + return bdd_error(BDD_VAR); + + l1 = bddvar2level[v1]; + l2 = bddvar2level[v2]; + + /* Make sure v1 is before v2 */ + if (l1 > l2) + { + int tmp = v1; + v1 = v2; + v2 = tmp; + l1 = bddvar2level[v1]; + l2 = bddvar2level[v2]; + } + + reorder_init(); + + /* Move v1 to v2's position */ + while (bddvar2level[v1] < l2) + reorder_vardown(v1); + + /* Move v2 to v1's position */ + while (bddvar2level[v2] > l1) + reorder_varup(v2); + + reorder_done(); + + return 0; +} + + +void bdd_default_reohandler(int prestate) +{ + static long c1; + + if (verbose > 0) + { + if (prestate) + { + printf("Start reordering\n"); + c1 = clock(); + } + else + { + long c2 = clock(); + printf("End reordering. Went from %d to %d nodes (%.1f sec)\n", + usednum_before, usednum_after, (float)(c2-c1)/CLOCKS_PER_SEC); + } + } +} + + +/* +NAME {* bdd\_disable\_reorder *} +SECTION {* reorder *} +SHORT {* Disable automatic reordering *} +PROTO {* void bdd_disable_reorder(void) *} +DESCR {* Disables automatic reordering until {\tt bdd\_enable\_reorder} + is called. Reordering is enabled by default as soon as any variable + blocks have been defined. *} +ALSO {* bdd\_enable\_reorder *} +*/ +void bdd_disable_reorder(void) +{ + reorderdisabled = 1; +} + + +/* +NAME {* bdd\_enable\_reorder *} +SECTION {* reorder *} +SHORT {* Enables automatic reordering *} +PROTO {* void bdd_enable_reorder(void) *} +DESCR {* Re-enables reordering after a call to {\tt bdd\_disable\_reorder}. *} +ALSO {* bdd\_disable\_reorder *} +*/ +void bdd_enable_reorder(void) +{ + reorderdisabled = 0; +} + + +int bdd_reorder_ready(void) +{ + if (bddreordermethod == BDD_REORDER_NONE || vartree == NULL || + bddreordertimes == 0 || reorderdisabled) + return 0; + return 1; +} + + +void bdd_reorder_auto(void) +{ + if (!bdd_reorder_ready) + return; + + if (reorder_handler != NULL) + reorder_handler(1); + + bdd_reorder(bddreordermethod); + bddreordertimes--; + + if (reorder_handler != NULL) + reorder_handler(0); +} + + +static int reorder_init(void) +{ + int n; + + if ((levels=NEW(levelData,bddvarnum)) == NULL) + return -1; + + for (n=0 ; n b) + return 1; + return 0; +} + + +static BddTree *reorder_block(BddTree *t, int method) +{ + BddTree *this; + + if (t == NULL) + return NULL; + + if (t->fixed == BDD_REORDER_FREE && t->nextlevel!=NULL) + { + switch(method) + { + case BDD_REORDER_WIN2: + t->nextlevel = reorder_win2(t->nextlevel); + break; + case BDD_REORDER_WIN2ITE: + t->nextlevel = reorder_win2ite(t->nextlevel); + break; + case BDD_REORDER_SIFT: + t->nextlevel = reorder_sift(t->nextlevel); + break; + case BDD_REORDER_SIFTITE: + t->nextlevel = reorder_siftite(t->nextlevel); + break; + case BDD_REORDER_WIN3: + t->nextlevel = reorder_win3(t->nextlevel); + break; + case BDD_REORDER_WIN3ITE: + t->nextlevel = reorder_win3ite(t->nextlevel); + break; + case BDD_REORDER_RANDOM: + t->nextlevel = reorder_random(t->nextlevel); + break; + } + } + + for (this=t->nextlevel ; this ; this=this->next) + reorder_block(this, method); + + if (t->seq != NULL) + qsort(t->seq, t->last-t->first+1, sizeof(int), varseqCmp); + + return t; +} + + +/* +NAME {* bdd\_reorder *} +SECTION {* reorder *} +SHORT {* start dynamic reordering *} +PROTO {* void bdd_reorder(int method) *} +DESCR {* This function initiates dynamic reordering using the heuristic + defined by {\tt method}, which may be one of the following + \begin{description} + \item {\tt BDD\_REORDER\_WIN2}\\ + Reordering using a sliding window of size 2. This algorithm + swaps two adjacent variable blocks and if this results in + more nodes then the two blocks are swapped back again. + Otherwise the result is kept in the variable order. This is + then repeated for all variable blocks. + \item {\tt BDD\_REORDER\_WIN2ITE}\\ + The same as above but the process is repeated until no further + progress is done. Usually a fast and efficient method. + \item {\tt BDD\_REORDER\_WIN3}\\ + The same as above but with a window size of 3. + \item {\tt BDD\_REORDER\_WIN2ITE}\\ + The same as above but with a window size of 3. + \item {\tt BDD\_REORDER\_SIFT}\\ + Reordering where each block is moved through all possible + positions. The best of these is then used as the new position. + Potentially a very slow but good method. + \item {\tt BDD\_REORDER\_SIFTITE}\\ + The same as above but the process is repeated until no further + progress is done. Can be extremely slow. + \item {\tt BDD\_REORDER\_RANDOM}\\ + Mostly used for debugging purpose, but may be usefull for + others. Selects a random position for each variable. + \end{description} + *} +ALSO {* bdd\_autoreorder, bdd\_reorder\_verbose, bdd\_addvarblock, bdd\_clrvarblocks *} +*/ +void bdd_reorder(int method) +{ + BddTree *top; + int savemethod = bddreordermethod; + int savetimes = bddreordertimes; + + bddreordermethod = method; + bddreordertimes = 1; + + if ((top=bddtree_new(-1)) == NULL) + return; + if (reorder_init() < 0) + return; + + usednum_before = bddnodesize - bddfreenum; + + top->first = 0; + top->last = bdd_varnum()-1; + top->fixed = 0; + top->next = NULL; + top->nextlevel = vartree; + + reorder_block(top, method); + vartree = top->nextlevel; + free(top); + + usednum_after = bddnodesize - bddfreenum; + + reorder_done(); + bddreordermethod = savemethod; + bddreordertimes = savetimes; +} + + +/* +NAME {* bdd\_reorder\_gain *} +SECTION {* reorder *} +SHORT {* Calculate the gain in size after a reordering *} +PROTO {* int bdd_reorder_gain(void) *} +DESCR {* Returns the gain in percent of the previous number of used + nodes. The value returned is + \[ (100 * (A - B)) / A \] + Where $A$ is previous number of used nodes and $B$ is current + number of used nodes. + *} +*/ +int bdd_reorder_gain(void) +{ + if (usednum_before == 0) + return 0; + + return (100*(usednum_before - usednum_after)) / usednum_before; +} + + +/* +NAME {* bdd\_reorder\_hook *} +SECTION {* reorder *} +SHORT {* sets a handler for automatic reorderings *} +PROTO {* bddinthandler bdd_reorder_hook(bddinthandler handler) *} +DESCR {* Whenever automatic reordering is done, a check is done to see + if the user has supplied a handler for that event. If so then + it is called with the argument {\tt prestate} being 1 if the + handler is called immediately {\em before} reordering and + {\tt prestate} being 0 if it is called immediately after. + The default handler is + {\tt bdd\_default\_reohandler} which will print information + about the reordering. + + A typical handler could look like this: + \begin{verbatim} +void reorderhandler(int prestate) +{ + if (prestate) + printf("Start reordering"); + else + printf("End reordering"); +} +\end{verbatim} *} +RETURN {* The previous handler *} +ALSO {* bdd\_reorder, bdd\_autoreorder, bdd\_resize\_hook *} +*/ +bddinthandler bdd_reorder_hook(bddinthandler handler) +{ + bddinthandler tmp = reorder_handler; + reorder_handler = handler; + return tmp; +} + + +/* +NAME {* bdd\_blockfile\_hook *} +SECTION {* reorder *} +SHORT {* Specifies a printing callback handler *} +PROTO {* bddfilehandler bdd_blockfile_hook(bddfilehandler handler) *} +DESCR {* A printing callback handler is used to convert the variable + block identifiers into something readable by the end user. Use + {\tt bdd\_blockfile\_hook} to pass a handler to BuDDy. A typical + handler could look like this: +\begin{verbatim} +void printhandler(FILE *o, int block) +{ + extern char **blocknames; + fprintf(o, "%s", blocknames[block]); +} +\end{verbatim} + \noindent + The handler is then called from {\tt bdd\_printorder} and + {\tt bdd\_reorder} (depending on the verbose level) with + the block numbers returned by {\tt bdd\_addvarblock} as arguments. + No default handler is supplied. The argument {\tt handler} may be + NULL if no handler is needed. *} +RETURN {* The old handler *} +ALSO {* bdd\_printorder *} +*/ +bddfilehandler bdd_blockfile_hook(bddfilehandler handler) +{ + bddfilehandler tmp = reorder_filehandler; + reorder_filehandler = handler; + return tmp; +} + + +/* +NAME {* bdd\_autoreorder *} +EXTRA {* bdd\_autoreorder\_times *} +SECTION {* reorder *} +SHORT {* enables automatic reordering *} +PROTO {* int bdd_autoreorder(int method) +int bdd_autoreorder_times(int method, int num) *} +DESCR {* Enables automatic reordering using {\tt method} as the reordering + method. If {\tt method} is {\tt BDD\_REORDER\_NONE} then + automatic reordering is disabled. Automatic + reordering is done every time the number of active nodes in the + node table has been doubled and works by interrupting the current + BDD operation, doing the reordering and the retrying the operation. + + In the second form the argument {\tt num} specifies the allowed + number of reorderings. So if for example a "one shot" reordering + is needed, then the {\tt num} argument would be set to one. + + Values for {\tt method} can be found under {\tt bdd\_reorder}. + *} +RETURN {* Returns the old value of {\tt method} *} +ALSO {* bdd\_reorder *} +*/ +int bdd_autoreorder(int method) +{ + int tmp = bddreordermethod; + bddreordermethod = method; + bddreordertimes = -1; + return tmp; +} + + +int bdd_autoreorder_times(int method, int num) +{ + int tmp = bddreordermethod; + bddreordermethod = method; + bddreordertimes = num; + return tmp; +} + + +/* +NAME {* bdd\_var2level *} +SECTION {* reorder *} +SHORT {* Fetch the level of a specific BDD variable *} +PROTO {* int bdd_var2level(int var) *} +DESCR {* Returns the position of the variable {\tt var} in the current + variable order. *} +ALSO {* bdd\_reorder, bdd\_level2var *} +*/ +int bdd_var2level(int var) +{ + if (var < 0 || var >= bddvarnum) + return bdd_error(BDD_VAR); + + return bddvar2level[var]; +} + + +/* +NAME {* bdd\_level2var *} +SECTION {* reorder *} +SHORT {* Fetch the variable number of a specific level *} +PROTO {* int bdd_level2var(int level) *} +DESCR {* Returns the variable placed at position {\tt level} in the + current variable order. *} +ALSO {* bdd\_reorder, bdd\_var2level *} +*/ +int bdd_level2var(int level) +{ + if (level < 0 || level >= bddvarnum) + return bdd_error(BDD_VAR); + + return bddlevel2var[level]; +} + + +/* +NAME {* bdd\_getreorder\_times *} +SECTION {* reorder *} +SHORT {* Fetch the current number of allowed reorderings *} +PROTO {* int bdd_getreorder_times(void) *} +DESCR {* Returns the current number of allowed reorderings left. This + value can be defined by {\tt bdd\_autoreorder\_times}. *} +ALSO {* bdd\_reorder\_times, bdd\_getreorder\_method *} +*/ +int bdd_getreorder_times(void) +{ + return bddreordertimes; +} + + +/* +NAME {* bdd\_getreorder\_method *} +SECTION {* reorder *} +SHORT {* Fetch the current reorder method *} +PROTO {* int bdd_getreorder_method(void) *} +DESCR {* Returns the current reorder method as defined by + {\tt bdd\_autoreorder}. *} +ALSO {* bdd\_reorder, bdd\_getreorder\_times *} +*/ +int bdd_getreorder_method(void) +{ + return bddreordermethod; +} + + +/* +NAME {* bdd\_reorder\_verbose *} +SECTION {* reorder *} +SHORT {* enables verbose information about reorderings *} +PROTO {* int bdd_reorder_verbose(int v) *} +DESCR {* With {\tt bdd\_reorder\_verbose} it is possible to set the level + of information which should be printed during reordering. A value + of zero means no information, a value of one means some information + and any greater value will result in a lot of reordering + information. The default value is zero. *} +RETURN {* The old verbose level *} +ALSO {* bdd\_reorder *} +*/ +int bdd_reorder_verbose(int v) +{ + int tmp = verbose; + verbose = v; + return tmp; +} + + +/* +NAME {* bdd\_reorder\_probe *} +SECTION {* reorder *} +SHORT {* Define a handler for minimization of BDDs *} +PROTO {* bddsizehandler bdd_reorder_probe(bddsizehandler handler) *} +DESCR {* Reordering is typically done to minimize the global number of + BDD nodes in use, but it may in some cases be usefull to minimize + with respect to a specific BDD. With {\tt bdd\_reorder\_probe} it + is possible to define a callback function that calculates the + size of a specific BDD (or anything else in fact). This handler + will then be called by the reordering functions to get the current + size information. A typical handle could look like this: +\begin{verbatim} +int sizehandler(void) +{ + extern BDD mybdd; + return bdd_nodecount(mybdd); +} +\end{verbatim} + No default handler is supplied. The argument {\tt handler} may be + NULL if no handler is needed. *} + *} +RETURN {* The old handler *} +ALSO {* bdd\_reorder *} +*/ +bddsizehandler bdd_reorder_probe(bddsizehandler handler) +{ + bddsizehandler old = reorder_nodenum; + if (handler == NULL) + return reorder_nodenum; + reorder_nodenum = handler; + return old; +} + + +/* +NAME {* bdd\_clrvarblocks *} +SECTION {* reorder *} +SHORT {* clears all variable blocks *} +PROTO {* void bdd_clrvarblocks(void) *} +DESCR {* Clears all the variable blocks that has been defined by calls + to bdd\_addvarblock. *} +ALSO {* bdd\_addvarblock *} +*/ +void bdd_clrvarblocks(void) +{ + bddtree_del(vartree); + vartree = NULL; + blockid = 0; +} + + +/* +NAME {* bdd\_addvarblock *} +EXTRA {* bdd\_intaddvarblock *} +SECTION {* reorder *} +SHORT {* adds a new variable block for reordering *} +PROTO {* int bdd_addvarblock(BDD var, int fixed) +int bdd_intaddvarblock(int first, int last, int fixed) *} +DESCR {* Creates a new variable block with the variables in the variable + set {\tt var}. The variables in {\tt var} must be contiguous. + In the second form the argument {\tt first} is the first variable + included in the block and {\tt last} is the last variable included + in the block. This order does not depend on current variable + order. + + The variable blocks are ordered as a tree, with the largest + ranges at top and the smallest at the bottom. Example: Assume + the block 0-9 is added as the first block and then the block 0-6. + This yields the 0-9 block at the top, with the 0-6 block as a + child. If now the block 2-4 was added, it would become a child + of the 0-6 block. A block of 0-8 would be a child of the 0-9 + block and have the 0-6 block as a child. Partially overlapping + blocks are not allowed. + + The {\tt fixed} parameter sets the block to be fixed (no + reordering of its child blocks is allowed) or free, using + the constants {\tt BDD\_REORDER\_FIXED} and {\tt + BDD\_REORDER\_FREE}. Reordering is always done on the top + most blocks first and then recursively downwards. + + The return value is an integer that can be used to identify + the block later on - with for example {\tt bdd\_blockfile\_hook}. + The values returned will be in the sequence $0,1,2,3,\ldots$. + *} +RETURN {* A non-negative identifier on success, otherwise a negative error code. *} +ALSO {* bdd\_varblockall, fdd\_intaddvarblock, bdd\_clrvarblocks *} */ +int bdd_addvarblock(BDD b, int fixed) +{ + BddTree *t; + int n, *v, size; + int first, last; + + if ((n=bdd_scanset(b, &v, &size)) < 0) + return n; + if (size < 1) + return bdd_error(BDD_VARBLK); + + first = last = v[0]; + + for (n=0 ; n last) + last = v[n]; + } + + if ((t=bddtree_addrange(vartree, first,last, fixed,blockid)) == NULL) + return bdd_error(BDD_VARBLK); + + vartree = t; + return blockid++; +} + + +int bdd_intaddvarblock(int first, int last, int fixed) +{ + BddTree *t; + + if (first < 0 || first >= bddvarnum || last < 0 || last >= bddvarnum) + return bdd_error(BDD_VAR); + + if ((t=bddtree_addrange(vartree, first,last, fixed,blockid)) == NULL) + return bdd_error(BDD_VARBLK); + + vartree = t; + return blockid++; +} + + +/* +NAME {* bdd\_varblockall *} +SECTION {* reorder *} +SHORT {* add a variable block for all variables *} +PROTO {* void bdd_varblockall(void) *} +DESCR {* Adds a variable block for all BDD variables declared so far. + Each block contains one variable only. More variable blocks + can be added later with the use of {\tt bdd\_addvarblock} -- + in this case the tree of variable blocks will have the blocks + of single variables as the leafs. *} +ALSO {* bdd\_addvarblock, bdd\_intaddvarblock *} +*/ +void bdd_varblockall(void) +{ + int n; + + for (n=0 ; n level) + reorder_varup(lowvar); + } + + reorder_done(); +} + + +static void print_order_rec(FILE *o, BddTree *t, int level) +{ + if (t == NULL) + return; + + if (t->nextlevel) + { + fprintf(o, "%*s", level*3, ""); + if (reorder_filehandler) + reorder_filehandler(o,t->id); + else + fprintf(o, "%3d", t->id); + fprintf(o, "{\n"); + + print_order_rec(o, t->nextlevel, level+1); + + fprintf(o, "%*s", level*3, ""); + if (reorder_filehandler) + reorder_filehandler(o,t->id); + else + fprintf(o, "%3d", t->id); + fprintf(o, "}\n"); + + print_order_rec(o, t->next, level); + } + else + { + fprintf(o, "%*s", level*3, ""); + if (reorder_filehandler) + reorder_filehandler(o,t->id); + else + fprintf(o, "%3d", t->id); + fprintf(o, "\n"); + + print_order_rec(o, t->next, level); + } +} + + + +void bdd_fprintorder(FILE *ofile) +{ + print_order_rec(ofile, vartree, 0); +} + + + +/* EOF */ diff --git a/sdk/buddy-2.4/src/tree.c b/sdk/buddy-2.4/src/tree.c new file mode 100644 index 0000000..450e79a --- /dev/null +++ b/sdk/buddy-2.4/src/tree.c @@ -0,0 +1,222 @@ +/*======================================================================== + Copyright (C) 1996-2002 by Jorn Lind-Nielsen + All rights reserved + + Permission is hereby granted, without written agreement and without + license or royalty fees, to use, reproduce, prepare derivative + works, distribute, and display this software and its documentation + for any purpose, provided that (1) the above copyright notice and + the following two paragraphs appear in all copies of the source code + and (2) redistributions, including without limitation binaries, + reproduce these notices in the supporting documentation. Substantial + modifications to this software may be copyrighted by their authors + and need not follow the licensing terms described here, provided + that the new terms are clearly indicated in all files where they apply. + + IN NO EVENT SHALL JORN LIND-NIELSEN, OR DISTRIBUTORS OF THIS + SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, + INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS + SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE + ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + JORN LIND-NIELSEN SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO + OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR + MODIFICATIONS. +========================================================================*/ + +/************************************************************************* + $Header: /cvsroot/buddy/buddy/src/tree.c,v 1.1.1.1 2004/06/25 13:23:00 haimcohen Exp $ + FILE: tree.c + DESCR: Trees for BDD variables + AUTH: Jorn Lind + DATE: (C) march 1998 +*************************************************************************/ +#include +#include +#include "kernel.h" +#include "bddtree.h" + +/************************************************************************* +*************************************************************************/ + +BddTree *bddtree_addrange_rec(BddTree *, BddTree *, int, int, int, int); + + +/*======================================================================*/ + +static void update_seq(BddTree *t) +{ + int n; + int low = t->first; + + for (n=t->first ; n<=t->last ; n++) + if (bddvar2level[n] < bddvar2level[low]) + low = n; + + for (n=t->first ; n<=t->last ; n++) + t->seq[bddvar2level[n]-bddvar2level[low]] = n; +} + + +BddTree *bddtree_new(int id) +{ + BddTree *t = NEW(BddTree,1); + if (t == NULL) + return NULL; + + t->first = t->last = -1; + t->fixed = 1; + t->next = t->prev = t->nextlevel = NULL; + t->seq = NULL; + t->id = id; + return t; +} + + +void bddtree_del(BddTree *t) +{ + if (t == NULL) + return; + + bddtree_del(t->nextlevel); + bddtree_del(t->next); + if (t->seq != NULL) + free(t->seq); + free(t); +} + + +BddTree *bddtree_addrange_rec(BddTree *t, BddTree *prev, + int first, int last, int fixed, int id) +{ + if (first < 0 || last < 0 || last < first) + return NULL; + + /* Empty tree -> build one */ + if (t == NULL) + { + if ((t=bddtree_new(id)) == NULL) + return NULL; + t->first = first; + t->fixed = fixed; + t->seq = NEW(int,last-first+1); + t->last = last; + update_seq(t); + t->prev = prev; + return t; + } + + /* Check for identity */ + if (first == t->first && last == t->last) + return t; + + /* Before this section -> insert */ + if (last < t->first) + { + BddTree *tnew = bddtree_new(id); + if (tnew == NULL) + return NULL; + tnew->first = first; + tnew->last = last; + tnew->fixed = fixed; + tnew->seq = NEW(int,last-first+1); + update_seq(tnew); + tnew->next = t; + tnew->prev = t->prev; + t->prev = tnew; + return tnew; + } + + /* After this this section -> go to next */ + if (first > t->last) + { + t->next = bddtree_addrange_rec(t->next, t, first, last, fixed, id); + return t; + } + + /* Inside this section -> insert in next level */ + if (first >= t->first && last <= t->last) + { + t->nextlevel = + bddtree_addrange_rec(t->nextlevel,NULL,first,last,fixed,id); + return t; + } + + /* Covering this section -> insert above this level */ + if (first <= t->first) + { + BddTree *tnew; + BddTree *this = t; + + while (1) + { + /* Partial cover ->error */ + if (last >= this->first && last < this->last) + return NULL; + + if (this->next == NULL || last < this->next->first) + { + tnew = bddtree_new(id); + if (tnew == NULL) + return NULL; + tnew->first = first; + tnew->last = last; + tnew->fixed = fixed; + tnew->seq = NEW(int,last-first+1); + update_seq(tnew); + tnew->nextlevel = t; + tnew->next = this->next; + tnew->prev = t->prev; + if (this->next != NULL) + this->next->prev = tnew; + this->next = NULL; + t->prev = NULL; + return tnew; + } + + this = this->next; + } + + } + + return NULL; +} + + +BddTree *bddtree_addrange(BddTree *t, int first, int last, int fixed,int id) +{ + return bddtree_addrange_rec(t,NULL,first,last,fixed,id); +} + + +#if 0 +int main(void) +{ + BddTree *t = NULL; + + t = bddtree_addrange(t, 8,10,1); + printf("A\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 2,99,1); + printf("B\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 11,50,1); + printf("C\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 5,7,1); + printf("D\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 5,10,1); + printf("E\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 100,150,1); + printf("F\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 60,65,1); + printf("G\n"); bddtree_print(stdout, t, 0); + t = bddtree_addrange(t, 3,200,1); + + printf("H\n"); bddtree_print(stdout, t, 0); + bddtree_del(t); + return 0; +} +#endif + +/* EOF */ diff --git a/sdk/buddy-2.4/stamp-h1 b/sdk/buddy-2.4/stamp-h1 new file mode 100644 index 0000000..4547fe1 --- /dev/null +++ b/sdk/buddy-2.4/stamp-h1 @@ -0,0 +1 @@ +timestamp for config.h diff --git a/sdk/buddy-2.4/tools/config.guess b/sdk/buddy-2.4/tools/config.guess new file mode 100644 index 0000000..2fc3acc --- /dev/null +++ b/sdk/buddy-2.4/tools/config.guess @@ -0,0 +1,1411 @@ +#! /bin/sh +# Attempt to guess a canonical system name. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + +timestamp='2003-06-17' + +# This file is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Originally written by Per Bothner . +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# This script attempts to guess a canonical system name similar to +# config.sub. If it succeeds, it prints the system name on stdout, and +# exits with 0. Otherwise, it exits with 1. +# +# The plan is that this can be called by configure scripts if you +# don't specify an explicit build system type. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 +Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit 0 ;; + --version | -v ) + echo "$version" ; exit 0 ;; + --help | --h* | -h ) + echo "$usage"; exit 0 ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +## for Red Hat Linux +if test -f /etc/redhat-release ; then + VENDOR=redhat ; +else + VENDOR= ; +fi + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep __ELF__ >/dev/null + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit 0 ;; + amiga:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + arc:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + hp300:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mac68k:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + macppc:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvme68k:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvme88k:OpenBSD:*:*) + echo m88k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvmeppc:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + pmax:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + sgi:OpenBSD:*:*) + echo mipseb-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + sun3:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + wgrisc:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + *:OpenBSD:*:*) + echo ${UNAME_MACHINE}-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + alpha:OSF1:*:*) + if test $UNAME_RELEASE = "V4.0"; then + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + fi + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + exit 0 ;; + Alpha*:OpenVMS:*:*) + echo alpha-hp-vms + exit 0 ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit 0 ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit 0 ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit 0;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit 0 ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit 0 ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit 0 ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit 0;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit 0;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit 0 ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit 0 ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit 0 ;; + DRS?6000:UNIX_SV:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7 && exit 0 ;; + esac ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + i86pc:SunOS:5.*:*) + echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit 0 ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit 0 ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit 0 ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit 0 ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit 0 ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit 0 ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit 0 ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit 0 ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit 0 ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit 0 ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit 0 ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit 0 ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c \ + && $dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \ + && exit 0 + echo mips-mips-riscos${UNAME_RELEASE} + exit 0 ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit 0 ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit 0 ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit 0 ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit 0 ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit 0 ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit 0 ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit 0 ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit 0 ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit 0 ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit 0 ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit 0 ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit 0 ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit 0 ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit 0 ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit 0 ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit 0 ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0 + echo rs6000-ibm-aix3.2.5 + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit 0 ;; + *:AIX:*:[45]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit 0 ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit 0 ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit 0 ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit 0 ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit 0 ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit 0 ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit 0 ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit 0 ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + # avoid double evaluation of $set_cc_for_build + test -n "$CC_FOR_BUILD" || eval $set_cc_for_build + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E -) | grep __LP64__ >/dev/null + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit 0 ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit 0 ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0 + echo unknown-hitachi-hiuxwe2 + exit 0 ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit 0 ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit 0 ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit 0 ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit 0 ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit 0 ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit 0 ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit 0 ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit 0 ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit 0 ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit 0 ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit 0 ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + *:UNICOS/mp:*:*) + echo nv1-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit 0 ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit 0 ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit 0 ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit 0 ;; + *:FreeBSD:*:*|*:GNU/FreeBSD:*:*) + # Determine whether the default compiler uses glibc. + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #if __GLIBC__ >= 2 + LIBC=gnu + #else + LIBC= + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=` + echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`${LIBC:+-$LIBC} + exit 0 ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit 0 ;; + i*:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit 0 ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit 0 ;; + x86:Interix*:[34]*) + echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//' + exit 0 ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit 0 ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit 0 ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit 0 ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit 0 ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + *:GNU:*:*) + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit 0 ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit 0 ;; + arm*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + cris:Linux:*:*) + echo cris-axis-linux-gnu + exit 0 ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-${VENDOR:-unknown}-linux-gnu + exit 0 ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + mips:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips + #undef mipsel + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mipsel + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=` + test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0 + ;; + mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips64 + #undef mips64el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mips64el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips64 + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=` + test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0 + ;; + ppc:Linux:*:*) + echo powerpc-${VENDOR:-unknown}-linux-gnu + exit 0 ;; + ppc64:Linux:*:*) + echo powerpc64-${VENDOR:-unknown}-linux-gnu + exit 0 ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null + if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi + echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} + exit 0 ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-gnu ;; + PA8*) echo hppa2.0-unknown-linux-gnu ;; + *) echo hppa-unknown-linux-gnu ;; + esac + exit 0 ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-gnu + exit 0 ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-${VENDOR:-ibm}-linux-gnu + exit 0 ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + x86_64:Linux:*:*) + echo x86_64-${VENDOR:-unknown}-linux-gnu + exit 0 ;; + i*86:Linux:*:*) + # The BFD linker knows what the default object file format is, so + # first see if it will tell us. cd to the root directory to prevent + # problems with other programs or directories called `ld' in the path. + # Set LC_ALL=C to ensure ld outputs messages in English. + ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ + | sed -ne '/supported targets:/!d + s/[ ][ ]*/ /g + s/.*supported targets: *// + s/ .*// + p'` + case "$ld_supported_targets" in + elf32-i386) + TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" + ;; + a.out-i386-linux) + echo "${UNAME_MACHINE}-pc-linux-gnuaout" + exit 0 ;; + coff-i386) + echo "${UNAME_MACHINE}-pc-linux-gnucoff" + exit 0 ;; + "") + # Either a pre-BFD a.out linker (linux-gnuoldld) or + # one that does not give us useful --help. + echo "${UNAME_MACHINE}-pc-linux-gnuoldld" + exit 0 ;; + esac + # Determine whether the default compiler is a.out or elf + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #ifdef __ELF__ + # ifdef __GLIBC__ + # if __GLIBC__ >= 2 + LIBC=gnu + # else + LIBC=gnulibc1 + # endif + # else + LIBC=gnulibc1 + # endif + #else + #ifdef __INTEL_COMPILER + LIBC=gnu + #else + LIBC=gnuaout + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=` + test x"${LIBC}" != x && echo "${UNAME_MACHINE}-${VENDOR:-pc}-linux-${LIBC}" && exit 0 + test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0 + ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit 0 ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit 0 ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit 0 ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit 0 ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit 0 ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit 0 ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit 0 ;; + i*86:*:5:[78]*) + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit 0 ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit 0 ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i386. + echo i386-pc-msdosdjgpp + exit 0 ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit 0 ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit 0 ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit 0 ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit 0 ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit 0 ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit 0 ;; + M68*:*:R3V[567]*:*) + test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;; + 3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && echo i486-ncr-sysv4.3${OS_REL} && exit 0 + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && echo i486-ncr-sysv4 && exit 0 ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit 0 ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit 0 ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit 0 ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit 0 ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit 0 ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit 0 ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit 0 ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit 0 ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit 0 ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit 0 ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit 0 ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit 0 ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit 0 ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit 0 ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit 0 ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit 0 ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit 0 ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit 0 ;; + *:Darwin:*:*) + case `uname -p` in + *86) UNAME_PROCESSOR=i686 ;; + powerpc) UNAME_PROCESSOR=powerpc ;; + esac + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit 0 ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit 0 ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit 0 ;; + NSR-[DGKLNPTVW]:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit 0 ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit 0 ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit 0 ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit 0 ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit 0 ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit 0 ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit 0 ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit 0 ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit 0 ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit 0 ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit 0 ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit 0 ;; +esac + +#echo '(No uname command or uname output not recognized.)' 1>&2 +#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 + +eval $set_cc_for_build +cat >$dummy.c < +# include +#endif +main () +{ +#if defined (sony) +#if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); +#else +#include + printf ("m68k-sony-newsos%s\n", +#ifdef NEWSOS4 + "4" +#else + "" +#endif + ); exit (0); +#endif +#endif + +#if defined (__arm) && defined (__acorn) && defined (__unix) + printf ("arm-acorn-riscix"); exit (0); +#endif + +#if defined (hp300) && !defined (hpux) + printf ("m68k-hp-bsd\n"); exit (0); +#endif + +#if defined (NeXT) +#if !defined (__ARCHITECTURE__) +#define __ARCHITECTURE__ "m68k" +#endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); +#endif + +#if defined (MULTIMAX) || defined (n16) +#if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); +#else +#if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); +#else + printf ("ns32k-encore-bsd\n"); exit (0); +#endif +#endif +#endif + +#if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); +#endif + +#if defined (sequent) +#if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); +#endif +#if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); +#endif +#endif + +#if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); + +#endif + +#if defined (vax) +# if !defined (ultrix) +# include +# if defined (BSD) +# if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); +# else +# if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# endif +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# else + printf ("vax-dec-ultrix\n"); exit (0); +# endif +#endif + +#if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); +#endif + + exit (1); +} +EOF + +$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && $dummy && exit 0 + +# Apollos put the system type in the environment. + +test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; } + +# Convex versions that predate uname can use getsysinfo(1) + +if [ -x /usr/convex/getsysinfo ] +then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit 0 ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + c34*) + echo c34-convex-bsd + exit 0 ;; + c38*) + echo c38-convex-bsd + exit 0 ;; + c4*) + echo c4-convex-bsd + exit 0 ;; + esac +fi + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/sdk/buddy-2.4/tools/config.sub b/sdk/buddy-2.4/tools/config.sub new file mode 100644 index 0000000..7cee3d6 --- /dev/null +++ b/sdk/buddy-2.4/tools/config.sub @@ -0,0 +1,1500 @@ +#! /bin/sh +# Configuration validation subroutine script. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + +timestamp='2003-06-18' + +# This file is (in principle) common to ALL GNU software. +# The presence of a machine in this file suggests that SOME GNU software +# can handle that machine. It does not imply ALL GNU software can. +# +# This file is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, +# Boston, MA 02111-1307, USA. + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# Configuration subroutine to validate and canonicalize a configuration type. +# Supply the specified configuration type as an argument. +# If it is invalid, we print an error message on stderr and exit with code 1. +# Otherwise, we print the canonical config type on stdout and succeed. + +# This file is supposed to be the same for all GNU packages +# and recognize all the CPU types, system types and aliases +# that are meaningful with *any* GNU software. +# Each package is responsible for reporting which valid configurations +# it does not support. The user should be able to distinguish +# a failure to support a valid configuration from a meaningless +# configuration. + +# The goal of this file is to map all the various variations of a given +# machine specification into a single specification in the form: +# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +# or in some cases, the newer four-part form: +# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +# It is wrong to echo any other type of specification. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + +Canonicalize a configuration name. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.sub ($timestamp) + +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 +Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit 0 ;; + --version | -v ) + echo "$version" ; exit 0 ;; + --help | --h* | -h ) + echo "$usage"; exit 0 ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit 0;; + + * ) + break ;; + esac +done + +case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; +esac + +# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). +# Here we must recognize all the valid KERNEL-OS combinations. +maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` +case $maybe_os in + nto-qnx* | linux-gnu* | freebsd*-gnu* | netbsd*-gnu* | storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; +esac + +### Let's recognize common machines as not being operating systems so +### that things like config.sub decstation-3100 work. We also +### recognize some manufacturers as not being operating systems, so we +### can provide default operating systems below. +case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis) + os= + basic_machine=$1 + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; +esac + +# Decode aliases for certain CPU-COMPANY combinations. +case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \ + | c4x | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | i370 | i860 | i960 | ia64 \ + | ip2k \ + | m32r | m68000 | m68k | m88k | mcore \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64vr | mips64vrel \ + | mips64orion | mips64orionel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | msp430 \ + | ns16k | ns32k \ + | openrisc | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ + | pyramid \ + | s390 | s390x \ + | sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv9 | sparcv9b \ + | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ + | v850 | v850e \ + | we32k \ + | x86 | xscale | xstormy16 | xtensa \ + | z8k) + basic_machine=$basic_machine-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12) + # Motorola 68HC11/12. + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* \ + | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ + | clipper-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* \ + | m32r-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | mcore-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipstx39-* | mipstx39el-* \ + | msp430-* \ + | none-* | np1-* | nv1-* | ns16k-* | ns32k-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ + | pyramid-* \ + | romp-* | rs6000-* \ + | s390-* | s390x-* \ + | sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \ + | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \ + | tahoe-* | thumb-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tron-* \ + | v850-* | v850e-* | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \ + | xtensa-* \ + | ymp-* \ + | z8k-*) + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + crds | unos) + basic_machine=m68k-crds + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; +# I'm not sure what "Sysv32" means. Should this be sysv3.2? + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + mingw32) + basic_machine=i386-pc + os=-mingw32 + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + mmix*) + basic_machine=mmix-knuth + os=-mmixware + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + nv1) + basic_machine=nv1-cray + os=-unicosmp + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + or32 | or32-*) + basic_machine=or32-unknown + os=-coff + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc) basic_machine=powerpc-unknown + ;; + ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tic54x | c54x*) + basic_machine=tic54x-unknown + os=-coff + ;; + tic55x | c55x*) + basic_machine=tic55x-unknown + os=-coff + ;; + tic6x | c6x*) + basic_machine=tic6x-unknown + os=-coff + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + +# Here we handle the default manufacturer of certain CPU types. It is in +# some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh3 | sh4 | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparc | sparcv9 | sparcv9b) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; +esac + +# Here we canonicalize certain aliases for manufacturers. +case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; +esac + +# Decode manufacturer-specific aliases for certain operating systems. + +if [ x"$os" != x"" ] +then +case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \ + | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* \ + | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -kaos*) + os=-kaos + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; +esac +else + +# Here we handle the default operating systems that come with various machines. +# The value should be what the vendor currently ships out the door with their +# machine or put another way, the most popular os provided with the machine. + +# Note that if you're going to try to match "-MANUFACTURER" here (say, +# "-sun"), then you have to tell the case statement up towards the top +# that MANUFACTURER isn't an operating system. Otherwise, code above +# will signal an error saying that MANUFACTURER isn't an operating +# system, and we'll never get to this point. + +case $basic_machine in + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + # This also exists in the configure program, but was not the + # default. + # os=-sunos4 + ;; + m68*-cisco) + os=-aout + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-ibm) + os=-aix + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; +esac +fi + +# Here we handle the case where we know the os, and the CPU type, but not the +# manufacturer. We pick the logical manufacturer. +vendor=unknown +case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; +esac + +echo $basic_machine$os +exit 0 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/sdk/buddy-2.4/tools/depcomp b/sdk/buddy-2.4/tools/depcomp new file mode 100644 index 0000000..25bdb18 --- /dev/null +++ b/sdk/buddy-2.4/tools/depcomp @@ -0,0 +1,526 @@ +#! /bin/sh +# depcomp - compile a program generating dependencies as side-effects + +scriptversion=2004-04-25.13 + +# Copyright (C) 1999, 2000, 2003, 2004 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Originally written by Alexandre Oliva . + +case $1 in + '') + echo "$0: No command. Try \`$0 --help' for more information." 1>&2 + exit 1; + ;; + -h | --h*) + cat <<\EOF +Usage: depcomp [--help] [--version] PROGRAM [ARGS] + +Run PROGRAMS ARGS to compile a file, generating dependencies +as side-effects. + +Environment variables: + depmode Dependency tracking mode. + source Source file read by `PROGRAMS ARGS'. + object Object file output by `PROGRAMS ARGS'. + depfile Dependency file to output. + tmpdepfile Temporary file to use when outputing dependencies. + libtool Whether libtool is used (yes/no). + +Report bugs to . +EOF + exit 0 + ;; + -v | --v*) + echo "depcomp $scriptversion" + exit 0 + ;; +esac + +if test -z "$depmode" || test -z "$source" || test -z "$object"; then + echo "depcomp: Variables source, object and depmode must be set" 1>&2 + exit 1 +fi +# `libtool' can also be set to `yes' or `no'. + +if test -z "$depfile"; then + base=`echo "$object" | sed -e 's,^.*/,,' -e 's,\.\([^.]*\)$,.P\1,'` + dir=`echo "$object" | sed 's,/.*$,/,'` + if test "$dir" = "$object"; then + dir= + fi + # FIXME: should be _deps on DOS. + depfile="$dir.deps/$base" +fi + +tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} + +rm -f "$tmpdepfile" + +# Some modes work just like other modes, but use different flags. We +# parameterize here, but still list the modes in the big case below, +# to make depend.m4 easier to write. Note that we *cannot* use a case +# here, because this file can only contain one case statement. +if test "$depmode" = hp; then + # HP compiler uses -M and no extra arg. + gccflag=-M + depmode=gcc +fi + +if test "$depmode" = dashXmstdout; then + # This is just like dashmstdout with a different argument. + dashmflag=-xM + depmode=dashmstdout +fi + +case "$depmode" in +gcc3) +## gcc 3 implements dependency tracking that does exactly what +## we want. Yay! Note: for some reason libtool 1.4 doesn't like +## it if -MD -MP comes after the -MF stuff. Hmm. + "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + mv "$tmpdepfile" "$depfile" + ;; + +gcc) +## There are various ways to get dependency output from gcc. Here's +## why we pick this rather obscure method: +## - Don't want to use -MD because we'd like the dependencies to end +## up in a subdir. Having to rename by hand is ugly. +## (We might end up doing this anyway to support other compilers.) +## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like +## -MM, not -M (despite what the docs say). +## - Using -M directly means running the compiler twice (even worse +## than renaming). + if test -z "$gccflag"; then + gccflag=-MD, + fi + "$@" -Wp,"$gccflag$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz +## The second -e expression handles DOS-style file names with drive letters. + sed -e 's/^[^:]*: / /' \ + -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" +## This next piece of magic avoids the `deleted header file' problem. +## The problem is that when a header file which appears in a .P file +## is deleted, the dependency causes make to die (because there is +## typically no way to rebuild the header). We avoid this by adding +## dummy dependencies for each header file. Too bad gcc doesn't do +## this for us directly. + tr ' ' ' +' < "$tmpdepfile" | +## Some versions of gcc put a space before the `:'. On the theory +## that the space means something, we add a space to the output as +## well. +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +sgi) + if test "$libtool" = yes; then + "$@" "-Wp,-MDupdate,$tmpdepfile" + else + "$@" -MDupdate "$tmpdepfile" + fi + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + + if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files + echo "$object : \\" > "$depfile" + + # Clip off the initial element (the dependent). Don't try to be + # clever and replace this with sed code, as IRIX sed won't handle + # lines with more than a fixed number of characters (4096 in + # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; + # the IRIX cc adds comments like `#:fec' to the end of the + # dependency line. + tr ' ' ' +' < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \ + tr ' +' ' ' >> $depfile + echo >> $depfile + + # The second pass generates a dummy entry for each header file. + tr ' ' ' +' < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ + >> $depfile + else + # The sourcefile does not contain any dependencies, so just + # store a dummy comment line, to avoid errors with the Makefile + # "include basename.Plo" scheme. + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +aix) + # The C for AIX Compiler uses -M and outputs the dependencies + # in a .u file. In older versions, this file always lives in the + # current directory. Also, the AIX compiler puts `$object:' at the + # start of each line; $object doesn't have directory information. + # Version 6 uses the directory in both cases. + stripped=`echo "$object" | sed 's/\(.*\)\..*$/\1/'` + tmpdepfile="$stripped.u" + if test "$libtool" = yes; then + "$@" -Wc,-M + else + "$@" -M + fi + stat=$? + + if test -f "$tmpdepfile"; then : + else + stripped=`echo "$stripped" | sed 's,^.*/,,'` + tmpdepfile="$stripped.u" + fi + + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + + if test -f "$tmpdepfile"; then + outname="$stripped.o" + # Each line is of the form `foo.o: dependent.h'. + # Do two passes, one to just change these to + # `$object: dependent.h' and one to simply `dependent.h:'. + sed -e "s,^$outname:,$object :," < "$tmpdepfile" > "$depfile" + sed -e "s,^$outname: \(.*\)$,\1:," < "$tmpdepfile" >> "$depfile" + else + # The sourcefile does not contain any dependencies, so just + # store a dummy comment line, to avoid errors with the Makefile + # "include basename.Plo" scheme. + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +icc) + # Intel's C compiler understands `-MD -MF file'. However on + # icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c + # ICC 7.0 will fill foo.d with something like + # foo.o: sub/foo.c + # foo.o: sub/foo.h + # which is wrong. We want: + # sub/foo.o: sub/foo.c + # sub/foo.o: sub/foo.h + # sub/foo.c: + # sub/foo.h: + # ICC 7.1 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using \ : + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + + "$@" -MD -MF "$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form `foo.o: dependent.h', + # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. + # Do two passes, one to just change these to + # `$object: dependent.h' and one to simply `dependent.h:'. + sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" | + sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +tru64) + # The Tru64 compiler uses -MD to generate dependencies as a side + # effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'. + # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put + # dependencies in `foo.d' instead, so we check for that too. + # Subdirectories are respected. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + + if test "$libtool" = yes; then + # Dependencies are output in .lo.d with libtool 1.4. + # They are output in .o.d with libtool 1.5. + tmpdepfile1="$dir.libs/$base.lo.d" + tmpdepfile2="$dir.libs/$base.o.d" + tmpdepfile3="$dir.libs/$base.d" + "$@" -Wc,-MD + else + tmpdepfile1="$dir$base.o.d" + tmpdepfile2="$dir$base.d" + tmpdepfile3="$dir$base.d" + "$@" -MD + fi + + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + if test -f "$tmpdepfile1"; then + tmpdepfile="$tmpdepfile1" + elif test -f "$tmpdepfile2"; then + tmpdepfile="$tmpdepfile2" + else + tmpdepfile="$tmpdepfile3" + fi + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" + # That's a tab and a space in the []. + sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" + else + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +#nosideeffect) + # This comment above is used by automake to tell side-effect + # dependency tracking mechanisms from slower ones. + +dashmstdout) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout, regardless of -o. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test $1 != '--mode=compile'; do + shift + done + shift + fi + + # Remove `-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + test -z "$dashmflag" && dashmflag=-M + # Require at least two characters before searching for `:' + # in the target name. This is to cope with DOS-style filenames: + # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise. + "$@" $dashmflag | + sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile" + rm -f "$depfile" + cat < "$tmpdepfile" > "$depfile" + tr ' ' ' +' < "$tmpdepfile" | \ +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +dashXmstdout) + # This case only exists to satisfy depend.m4. It is never actually + # run, as this mode is specially recognized in the preamble. + exit 1 + ;; + +makedepend) + "$@" || exit $? + # Remove any Libtool call + if test "$libtool" = yes; then + while test $1 != '--mode=compile'; do + shift + done + shift + fi + # X makedepend + shift + cleared=no + for arg in "$@"; do + case $cleared in + no) + set ""; shift + cleared=yes ;; + esac + case "$arg" in + -D*|-I*) + set fnord "$@" "$arg"; shift ;; + # Strip any option that makedepend may not understand. Remove + # the object too, otherwise makedepend will parse it as a source file. + -*|$object) + ;; + *) + set fnord "$@" "$arg"; shift ;; + esac + done + obj_suffix="`echo $object | sed 's/^.*\././'`" + touch "$tmpdepfile" + ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" + rm -f "$depfile" + cat < "$tmpdepfile" > "$depfile" + sed '1,2d' "$tmpdepfile" | tr ' ' ' +' | \ +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" "$tmpdepfile".bak + ;; + +cpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test $1 != '--mode=compile'; do + shift + done + shift + fi + + # Remove `-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + "$@" -E | + sed -n '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' | + sed '$ s: \\$::' > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + cat < "$tmpdepfile" >> "$depfile" + sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvisualcpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout, regardless of -o, + # because we must use -o when running libtool. + "$@" || exit $? + IFS=" " + for arg + do + case "$arg" in + "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") + set fnord "$@" + shift + shift + ;; + *) + set fnord "$@" "$arg" + shift + shift + ;; + esac + done + "$@" -E | + sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile" + echo " " >> "$depfile" + . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::\1\::p' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +none) + exec "$@" + ;; + +*) + echo "Unknown depmode $depmode" 1>&2 + exit 1 + ;; +esac + +exit 0 + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-end: "$" +# End: diff --git a/sdk/buddy-2.4/tools/install-sh b/sdk/buddy-2.4/tools/install-sh new file mode 100644 index 0000000..e4160c9 --- /dev/null +++ b/sdk/buddy-2.4/tools/install-sh @@ -0,0 +1,325 @@ +#!/bin/sh +# install - install a program, script, or datafile + +scriptversion=2004-04-01.17 + +# This originates from X11R5 (mit/util/scripts/install.sh), which was +# later released in X11R6 (xc/config/util/install.sh) with the +# following copyright and license. +# +# Copyright (C) 1994 X Consortium +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- +# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# Except as contained in this notice, the name of the X Consortium shall not +# be used in advertising or otherwise to promote the sale, use or other deal- +# ings in this Software without prior written authorization from the X Consor- +# tium. +# +# +# FSF changes to this file are in the public domain. +# +# Calling this script install-sh is preferred over install.sh, to prevent +# `make' implicit rules from creating a file called install from it +# when there is no Makefile. +# +# This script is compatible with the BSD install script, but was written +# from scratch. It can only install one file at a time, a restriction +# shared with many OS's install programs. + +# set DOITPROG to echo to test this script + +# Don't use :- since 4.3BSD and earlier shells don't like it. +doit="${DOITPROG-}" + +# put in absolute paths if you don't have them in your path; or use env. vars. + +mvprog="${MVPROG-mv}" +cpprog="${CPPROG-cp}" +chmodprog="${CHMODPROG-chmod}" +chownprog="${CHOWNPROG-chown}" +chgrpprog="${CHGRPPROG-chgrp}" +stripprog="${STRIPPROG-strip}" +rmprog="${RMPROG-rm}" +mkdirprog="${MKDIRPROG-mkdir}" + +transformbasename= +transform_arg= +instcmd="$mvprog" +chmodcmd="$chmodprog 0755" +chowncmd= +chgrpcmd= +stripcmd= +rmcmd="$rmprog -f" +mvcmd="$mvprog" +src= +dst= +dir_arg= + +usage="Usage: $0 [OPTION]... SRCFILE DSTFILE + or: $0 [OPTION]... SRCFILES... DIRECTORY + or: $0 -d DIRECTORIES... + +In the first form, install SRCFILE to DSTFILE, removing SRCFILE by default. +In the second, create the directory path DIR. + +Options: +-b=TRANSFORMBASENAME +-c copy source (using $cpprog) instead of moving (using $mvprog). +-d create directories instead of installing files. +-g GROUP $chgrp installed files to GROUP. +-m MODE $chmod installed files to MODE. +-o USER $chown installed files to USER. +-s strip installed files (using $stripprog). +-t=TRANSFORM +--help display this help and exit. +--version display version info and exit. + +Environment variables override the default commands: + CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG +" + +while test -n "$1"; do + case $1 in + -b=*) transformbasename=`echo $1 | sed 's/-b=//'` + shift + continue;; + + -c) instcmd=$cpprog + shift + continue;; + + -d) dir_arg=true + shift + continue;; + + -g) chgrpcmd="$chgrpprog $2" + shift + shift + continue;; + + --help) echo "$usage"; exit 0;; + + -m) chmodcmd="$chmodprog $2" + shift + shift + continue;; + + -o) chowncmd="$chownprog $2" + shift + shift + continue;; + + -s) stripcmd=$stripprog + shift + continue;; + + -t=*) transformarg=`echo $1 | sed 's/-t=//'` + shift + continue;; + + --version) echo "$0 $scriptversion"; exit 0;; + + *) # When -d is used, all remaining arguments are directories to create. + test -n "$dir_arg" && break + # Otherwise, the last argument is the destination. Remove it from $@. + for arg + do + if test -n "$dstarg"; then + # $@ is not empty: it contains at least $arg. + set fnord "$@" "$dstarg" + shift # fnord + fi + shift # arg + dstarg=$arg + done + break;; + esac +done + +if test -z "$1"; then + if test -z "$dir_arg"; then + echo "$0: no input file specified." >&2 + exit 1 + fi + # It's OK to call `install-sh -d' without argument. + # This can happen when creating conditional directories. + exit 0 +fi + +for src +do + # Protect names starting with `-'. + case $src in + -*) src=./$src ;; + esac + + if test -n "$dir_arg"; then + dst=$src + src= + + if test -d "$dst"; then + instcmd=: + chmodcmd= + else + instcmd=$mkdirprog + fi + else + # Waiting for this to be detected by the "$instcmd $src $dsttmp" command + # might cause directories to be created, which would be especially bad + # if $src (and thus $dsttmp) contains '*'. + if test ! -f "$src" && test ! -d "$src"; then + echo "$0: $src does not exist." >&2 + exit 1 + fi + + if test -z "$dstarg"; then + echo "$0: no destination specified." >&2 + exit 1 + fi + + dst=$dstarg + # Protect names starting with `-'. + case $dst in + -*) dst=./$dst ;; + esac + + # If destination is a directory, append the input filename; won't work + # if double slashes aren't ignored. + if test -d "$dst"; then + dst=$dst/`basename "$src"` + fi + fi + + # This sed command emulates the dirname command. + dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` + + # Make sure that the destination directory exists. + + # Skip lots of stat calls in the usual case. + if test ! -d "$dstdir"; then + defaultIFS=' + ' + IFS="${IFS-$defaultIFS}" + + oIFS=$IFS + # Some sh's can't handle IFS=/ for some reason. + IFS='%' + set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'` + IFS=$oIFS + + pathcomp= + + while test $# -ne 0 ; do + pathcomp=$pathcomp$1 + shift + if test ! -d "$pathcomp"; then + $mkdirprog "$pathcomp" || lasterr=$? + # mkdir can fail with a `File exist' error in case several + # install-sh are creating the directory concurrently. This + # is OK. + test ! -d "$pathcomp" && { (exit ${lasterr-1}); exit; } + fi + pathcomp=$pathcomp/ + done + fi + + if test -n "$dir_arg"; then + $doit $instcmd "$dst" \ + && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \ + && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \ + && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \ + && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; } + + else + # If we're going to rename the final executable, determine the name now. + if test -z "$transformarg"; then + dstfile=`basename "$dst"` + else + dstfile=`basename "$dst" $transformbasename \ + | sed $transformarg`$transformbasename + fi + + # don't allow the sed command to completely eliminate the filename. + test -z "$dstfile" && dstfile=`basename "$dst"` + + # Make a couple of temp file names in the proper directory. + dsttmp=$dstdir/_inst.$$_ + rmtmp=$dstdir/_rm.$$_ + + # Trap to clean up those temp files at exit. + trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0 + trap '(exit $?); exit' 1 2 13 15 + + # Move or copy the file name to the temp name + $doit $instcmd "$src" "$dsttmp" && + + # and set any options; do chmod last to preserve setuid bits. + # + # If any of these fail, we abort the whole thing. If we want to + # ignore errors from any of these, just make sure not to ignore + # errors from the above "$doit $instcmd $src $dsttmp" command. + # + { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \ + && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \ + && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \ + && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } && + + # Now rename the file to the real destination. + { $doit $mvcmd -f "$dsttmp" "$dstdir/$dstfile" 2>/dev/null \ + || { + # The rename failed, perhaps because mv can't rename something else + # to itself, or perhaps because mv is so ancient that it does not + # support -f. + + # Now remove or move aside any old file at destination location. + # We try this two ways since rm can't unlink itself on some + # systems and the destination file might be busy for other + # reasons. In this case, the final cleanup might fail but the new + # file should still install successfully. + { + if test -f "$dstdir/$dstfile"; then + $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \ + || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \ + || { + echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2 + (exit 1); exit + } + else + : + fi + } && + + # Now rename the file to the real destination. + $doit $mvcmd "$dsttmp" "$dstdir/$dstfile" + } + } + fi || { (exit 1); exit; } +done + +# The final little trick to "correctly" pass the exit status to the exit trap. +{ + (exit 0); exit +} + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-end: "$" +# End: diff --git a/sdk/buddy-2.4/tools/ltmain.sh b/sdk/buddy-2.4/tools/ltmain.sh new file mode 100644 index 0000000..6828dc0 --- /dev/null +++ b/sdk/buddy-2.4/tools/ltmain.sh @@ -0,0 +1,6443 @@ +# ltmain.sh - Provide generalized library-building support services. +# NOTE: Changing this file will not affect anything until you rerun configure. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 +# Free Software Foundation, Inc. +# Originally by Gordon Matzigkeit , 1996 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +basename="s,^.*/,,g" + +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh +# is ksh but when the shell is invoked as "sh" and the current value of +# the _XPG environment variable is not equal to 1 (one), the special +# positional parameter $0, within a function call, is the name of the +# function. +progpath="$0" + +# define SED for historic ltconfig's generated by Libtool 1.3 +test -z "$SED" && SED=sed + +# The name of this program: +progname=`echo "$progpath" | $SED $basename` +modename="$progname" + +# Global variables: +EXIT_SUCCESS=0 +EXIT_FAILURE=1 + +PROGRAM=ltmain.sh +PACKAGE=libtool +VERSION=1.5.6 +TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42)" + + +# Check that we have a working $echo. +if test "X$1" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift +elif test "X$1" = X--fallback-echo; then + # Avoid inline document here, it may be left over + : +elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then + # Yippee, $echo works! + : +else + # Restart under the correct shell, and then maybe $echo will work. + exec $SHELL "$progpath" --no-reexec ${1+"$@"} +fi + +if test "X$1" = X--fallback-echo; then + # used as fallback echo + shift + cat <&2 + $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 + exit $EXIT_FAILURE +fi + +# Global variables. +mode=$default_mode +nonopt= +prev= +prevopt= +run= +show="$echo" +show_help= +execute_dlfiles= +lo2o="s/\\.lo\$/.${objext}/" +o2lo="s/\\.${objext}\$/.lo/" + +##################################### +# Shell function definitions: +# This seems to be the best place for them + +# func_win32_libid arg +# return the library type of file 'arg' +# +# Need a lot of goo to handle *both* DLLs and import libs +# Has to be a shell function in order to 'eat' the argument +# that is supplied when $file_magic_command is called. +func_win32_libid () { + win32_libid_type="unknown" + win32_fileres=`file -L $1 2>/dev/null` + case $win32_fileres in + *ar\ archive\ import\ library*) # definitely import + win32_libid_type="x86 archive import" + ;; + *ar\ archive*) # could be an import, or static + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \ + $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then + win32_nmres=`eval $NM -f posix -A $1 | \ + sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'` + if test "X$win32_nmres" = "Ximport" ; then + win32_libid_type="x86 archive import" + else + win32_libid_type="x86 archive static" + fi + fi + ;; + *DLL*) + win32_libid_type="x86 DLL" + ;; + *executable*) # but shell scripts are "executable" too... + case $win32_fileres in + *MS\ Windows\ PE\ Intel*) + win32_libid_type="x86 DLL" + ;; + esac + ;; + esac + $echo $win32_libid_type +} + + +# func_infer_tag arg +# Infer tagged configuration to use if any are available and +# if one wasn't chosen via the "--tag" command line option. +# Only attempt this if the compiler in the base compile +# command doesn't match the default compiler. +# arg is usually of the form 'gcc ...' +func_infer_tag () { + if test -n "$available_tags" && test -z "$tagname"; then + CC_quoted= + for arg in $CC; do + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + CC_quoted="$CC_quoted $arg" + done + case $@ in + # Blanks in the command may have been stripped by the calling shell, + # but not from the CC environment variable when configure was run. + " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;; + # Blanks at the start of $base_compile will cause this to fail + # if we don't check for them as well. + *) + for z in $available_tags; do + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" + CC_quoted= + for arg in $CC; do + # Double-quote args containing other shell metacharacters. + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + CC_quoted="$CC_quoted $arg" + done + case "$@ " in + " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) + # The compiler in the base compile command matches + # the one in the tagged configuration. + # Assume this is the tagged configuration we want. + tagname=$z + break + ;; + esac + fi + done + # If $tagname still isn't set, then no tagged configuration + # was found and let the user know that the "--tag" command + # line option must be used. + if test -z "$tagname"; then + $echo "$modename: unable to infer tagged configuration" + $echo "$modename: specify a tag with \`--tag'" 1>&2 + exit $EXIT_FAILURE +# else +# $echo "$modename: using $tagname tagged configuration" + fi + ;; + esac + fi +} +# End of Shell function definitions +##################################### + +# Darwin sucks +#eval std_shrext=\"$shrext_cmds\" + +# And fixing for Darwin sucks for everybody else +if test -z "$shrext_cmds" && test -n "$shrext"; then + eval shrext_cmds=\"$shrext\" +fi +eval std_shrext=\"$shrext_cmds\" + +# This value is evaluated to 32768, so place it here as a compatilibity hack +# because older libtool.m4 didn't define this variable +test -z "$max_cmd_len" && max_cmd_len=32768 + +# Parse our command line options once, thoroughly. +while test "$#" -gt 0 +do + arg="$1" + shift + + case $arg in + -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + execute_dlfiles) + execute_dlfiles="$execute_dlfiles $arg" + ;; + tag) + tagname="$arg" + preserve_args="${preserve_args}=$arg" + + # Check whether tagname contains only valid characters + case $tagname in + *[!-_A-Za-z0-9,/]*) + $echo "$progname: invalid tag name: $tagname" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + case $tagname in + CC) + # Don't test for the "default" C tag, as we know, it's there, but + # not specially marked. + ;; + *) + if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then + taglist="$taglist $tagname" + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`" + else + $echo "$progname: ignoring unknown tag $tagname" 1>&2 + fi + ;; + esac + ;; + *) + eval "$prev=\$arg" + ;; + esac + + prev= + prevopt= + continue + fi + + # Have we seen a non-optional argument yet? + case $arg in + --help) + show_help=yes + ;; + + --version) + $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP" + $echo + $echo "Copyright (C) 2003 Free Software Foundation, Inc." + $echo "This is free software; see the source for copying conditions. There is NO" + $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + exit $EXIT_SUCCESS + ;; + + --config) + ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath + # Now print the configurations for the tags. + for tagname in $taglist; do + ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath" + done + exit $EXIT_SUCCESS + ;; + + --debug) + $echo "$progname: enabling shell trace mode" + set -x + preserve_args="$preserve_args $arg" + ;; + + --dry-run | -n) + run=: + ;; + + --features) + $echo "host: $host" + if test "$build_libtool_libs" = yes; then + $echo "enable shared libraries" + else + $echo "disable shared libraries" + fi + if test "$build_old_libs" = yes; then + $echo "enable static libraries" + else + $echo "disable static libraries" + fi + exit $EXIT_SUCCESS + ;; + + --finish) mode="finish" ;; + + --mode) prevopt="--mode" prev=mode ;; + --mode=*) mode="$optarg" ;; + + --preserve-dup-deps) duplicate_deps="yes" ;; + + --quiet | --silent) + show=: + preserve_args="$preserve_args $arg" + ;; + + --tag) prevopt="--tag" prev=tag ;; + --tag=*) + set tag "$optarg" ${1+"$@"} + shift + prev=tag + preserve_args="$preserve_args --tag" + ;; + + -dlopen) + prevopt="-dlopen" + prev=execute_dlfiles + ;; + + -*) + $echo "$modename: unrecognized option \`$arg'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + + *) + nonopt="$arg" + break + ;; + esac +done + +if test -n "$prevopt"; then + $echo "$modename: option \`$prevopt' requires an argument" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE +fi + +# If this variable is set in any of the actions, the command in it +# will be execed at the end. This prevents here-documents from being +# left over by shells. +exec_cmd= + +if test -z "$show_help"; then + + # Infer the operation mode. + if test -z "$mode"; then + $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2 + $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2 + case $nonopt in + *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*) + mode=link + for arg + do + case $arg in + -c) + mode=compile + break + ;; + esac + done + ;; + *db | *dbx | *strace | *truss) + mode=execute + ;; + *install*|cp|mv) + mode=install + ;; + *rm) + mode=uninstall + ;; + *) + # If we have no mode, but dlfiles were specified, then do execute mode. + test -n "$execute_dlfiles" && mode=execute + + # Just use the default operation mode. + if test -z "$mode"; then + if test -n "$nonopt"; then + $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2 + else + $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2 + fi + fi + ;; + esac + fi + + # Only execute mode is allowed to have -dlopen flags. + if test -n "$execute_dlfiles" && test "$mode" != execute; then + $echo "$modename: unrecognized option \`-dlopen'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Change the help message to a mode-specific one. + generic_help="$help" + help="Try \`$modename --help --mode=$mode' for more information." + + # These modes are in order of execution frequency so that they run quickly. + case $mode in + # libtool compile mode + compile) + modename="$modename: compile" + # Get the compilation command and the source file. + base_compile= + srcfile="$nonopt" # always keep a non-empty value in "srcfile" + suppress_opt=yes + suppress_output= + arg_mode=normal + libobj= + later= + + for arg + do + case "$arg_mode" in + arg ) + # do not "continue". Instead, add this to base_compile + lastarg="$arg" + arg_mode=normal + ;; + + target ) + libobj="$arg" + arg_mode=normal + continue + ;; + + normal ) + # Accept any command-line options. + case $arg in + -o) + if test -n "$libobj" ; then + $echo "$modename: you cannot specify \`-o' more than once" 1>&2 + exit $EXIT_FAILURE + fi + arg_mode=target + continue + ;; + + -static | -prefer-pic | -prefer-non-pic) + later="$later $arg" + continue + ;; + + -no-suppress) + suppress_opt=no + continue + ;; + + -Xcompiler) + arg_mode=arg # the next one goes into the "base_compile" arg list + continue # The current "srcfile" will either be retained or + ;; # replaced later. I would guess that would be a bug. + + -Wc,*) + args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"` + lastarg= + save_ifs="$IFS"; IFS=',' + for arg in $args; do + IFS="$save_ifs" + + # Double-quote args containing other shell metacharacters. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + lastarg="$lastarg $arg" + done + IFS="$save_ifs" + lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"` + + # Add the arguments to base_compile. + base_compile="$base_compile $lastarg" + continue + ;; + + * ) + # Accept the current argument as the source file. + # The previous "srcfile" becomes the current argument. + # + lastarg="$srcfile" + srcfile="$arg" + ;; + esac # case $arg + ;; + esac # case $arg_mode + + # Aesthetically quote the previous argument. + lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"` + + case $lastarg in + # Double-quote args containing other shell metacharacters. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + lastarg="\"$lastarg\"" + ;; + esac + + base_compile="$base_compile $lastarg" + done # for arg + + case $arg_mode in + arg) + $echo "$modename: you must specify an argument for -Xcompile" + exit $EXIT_FAILURE + ;; + target) + $echo "$modename: you must specify a target with \`-o'" 1>&2 + exit $EXIT_FAILURE + ;; + *) + # Get the name of the library object. + [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'` + ;; + esac + + # Recognize several different file suffixes. + # If the user specifies -o file.o, it is replaced with file.lo + xform='[cCFSifmso]' + case $libobj in + *.ada) xform=ada ;; + *.adb) xform=adb ;; + *.ads) xform=ads ;; + *.asm) xform=asm ;; + *.c++) xform=c++ ;; + *.cc) xform=cc ;; + *.ii) xform=ii ;; + *.class) xform=class ;; + *.cpp) xform=cpp ;; + *.cxx) xform=cxx ;; + *.f90) xform=f90 ;; + *.for) xform=for ;; + *.java) xform=java ;; + esac + + libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"` + + case $libobj in + *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;; + *) + $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + func_infer_tag $base_compile + + for arg in $later; do + case $arg in + -static) + build_old_libs=yes + continue + ;; + + -prefer-pic) + pic_mode=yes + continue + ;; + + -prefer-non-pic) + pic_mode=no + continue + ;; + esac + done + + objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'` + xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$obj"; then + xdir= + else + xdir=$xdir/ + fi + lobj=${xdir}$objdir/$objname + + if test -z "$base_compile"; then + $echo "$modename: you must specify a compilation command" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Delete any leftover library objects. + if test "$build_old_libs" = yes; then + removelist="$obj $lobj $libobj ${libobj}T" + else + removelist="$lobj $libobj ${libobj}T" + fi + + $run $rm $removelist + trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15 + + # On Cygwin there's no "real" PIC flag so we must build both object types + case $host_os in + cygwin* | mingw* | pw32* | os2*) + pic_mode=default + ;; + esac + if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then + # non-PIC code in shared libraries is not supported + pic_mode=default + fi + + # Calculate the filename of the output object if compiler does + # not support -o with -c + if test "$compiler_c_o" = no; then + output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext} + lockfile="$output_obj.lock" + removelist="$removelist $output_obj $lockfile" + trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15 + else + output_obj= + need_locks=no + lockfile= + fi + + # Lock this critical section if it is needed + # We use this script file to make the link, it avoids creating a new file + if test "$need_locks" = yes; then + until $run ln "$progpath" "$lockfile" 2>/dev/null; do + $show "Waiting for $lockfile to be removed" + sleep 2 + done + elif test "$need_locks" = warn; then + if test -f "$lockfile"; then + $echo "\ +*** ERROR, $lockfile exists and contains: +`cat $lockfile 2>/dev/null` + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $run $rm $removelist + exit $EXIT_FAILURE + fi + $echo $srcfile > "$lockfile" + fi + + if test -n "$fix_srcfile_path"; then + eval srcfile=\"$fix_srcfile_path\" + fi + + $run $rm "$libobj" "${libobj}T" + + # Create a libtool object file (analogous to a ".la" file), + # but don't create it if we're doing a dry run. + test -z "$run" && cat > ${libobj}T </dev/null`" != "X$srcfile"; then + $echo "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $run $rm $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed, then go on to compile the next one + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then + $show "$mv $output_obj $lobj" + if $run $mv $output_obj $lobj; then : + else + error=$? + $run $rm $removelist + exit $error + fi + fi + + # Append the name of the PIC object to the libtool object file. + test -z "$run" && cat >> ${libobj}T <> ${libobj}T </dev/null`" != "X$srcfile"; then + $echo "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $run $rm $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then + $show "$mv $output_obj $obj" + if $run $mv $output_obj $obj; then : + else + error=$? + $run $rm $removelist + exit $error + fi + fi + + # Append the name of the non-PIC object the libtool object file. + # Only append if the libtool object file exists. + test -z "$run" && cat >> ${libobj}T <> ${libobj}T <&2 + fi + if test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + else + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + fi + build_libtool_libs=no + build_old_libs=yes + prefer_static_libs=yes + break + ;; + esac + done + + # See if our shared archives depend on static archives. + test -n "$old_archive_from_new_cmds" && build_old_libs=yes + + # Go through the arguments, transforming them on the way. + while test "$#" -gt 0; do + arg="$1" + shift + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test + ;; + *) qarg=$arg ;; + esac + libtool_args="$libtool_args $qarg" + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + output) + compile_command="$compile_command @OUTPUT@" + finalize_command="$finalize_command @OUTPUT@" + ;; + esac + + case $prev in + dlfiles|dlprefiles) + if test "$preload" = no; then + # Add the symbol object into the linking commands. + compile_command="$compile_command @SYMFILE@" + finalize_command="$finalize_command @SYMFILE@" + preload=yes + fi + case $arg in + *.la | *.lo) ;; # We handle these cases below. + force) + if test "$dlself" = no; then + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + self) + if test "$prev" = dlprefiles; then + dlself=yes + elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then + dlself=yes + else + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + *) + if test "$prev" = dlfiles; then + dlfiles="$dlfiles $arg" + else + dlprefiles="$dlprefiles $arg" + fi + prev= + continue + ;; + esac + ;; + expsyms) + export_symbols="$arg" + if test ! -f "$arg"; then + $echo "$modename: symbol file \`$arg' does not exist" + exit $EXIT_FAILURE + fi + prev= + continue + ;; + expsyms_regex) + export_symbols_regex="$arg" + prev= + continue + ;; + inst_prefix) + inst_prefix_dir="$arg" + prev= + continue + ;; + precious_regex) + precious_files_regex="$arg" + prev= + continue + ;; + release) + release="-$arg" + prev= + continue + ;; + objectlist) + if test -f "$arg"; then + save_arg=$arg + moreargs= + for fil in `cat $save_arg` + do +# moreargs="$moreargs $fil" + arg=$fil + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + pic_object= + non_pic_object= + + # Read the .lo file + # If there is no directory component, then add one. + case $arg in + */* | *\\*) . $arg ;; + *) . ./$arg ;; + esac + + if test -z "$pic_object" || \ + test -z "$non_pic_object" || + test "$pic_object" = none && \ + test "$non_pic_object" = none; then + $echo "$modename: cannot find name of object for \`$arg'" 1>&2 + exit $EXIT_FAILURE + fi + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + dlfiles="$dlfiles $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + dlprefiles="$dlprefiles $pic_object" + prev= + fi + + # A PIC object. + libobjs="$libobjs $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + non_pic_objects="$non_pic_objects $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + fi + else + # Only an error if not doing a dry-run. + if test -z "$run"; then + $echo "$modename: \`$arg' is not a valid libtool object" 1>&2 + exit $EXIT_FAILURE + else + # Dry-run case. + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"` + non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"` + libobjs="$libobjs $pic_object" + non_pic_objects="$non_pic_objects $non_pic_object" + fi + fi + done + else + $echo "$modename: link input file \`$save_arg' does not exist" + exit $EXIT_FAILURE + fi + arg=$save_arg + prev= + continue + ;; + rpath | xrpath) + # We need an absolute path. + case $arg in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + $echo "$modename: only absolute run-paths are allowed" 1>&2 + exit $EXIT_FAILURE + ;; + esac + if test "$prev" = rpath; then + case "$rpath " in + *" $arg "*) ;; + *) rpath="$rpath $arg" ;; + esac + else + case "$xrpath " in + *" $arg "*) ;; + *) xrpath="$xrpath $arg" ;; + esac + fi + prev= + continue + ;; + xcompiler) + compiler_flags="$compiler_flags $qarg" + prev= + compile_command="$compile_command $qarg" + finalize_command="$finalize_command $qarg" + continue + ;; + xlinker) + linker_flags="$linker_flags $qarg" + compiler_flags="$compiler_flags $wl$qarg" + prev= + compile_command="$compile_command $wl$qarg" + finalize_command="$finalize_command $wl$qarg" + continue + ;; + xcclinker) + linker_flags="$linker_flags $qarg" + compiler_flags="$compiler_flags $qarg" + prev= + compile_command="$compile_command $qarg" + finalize_command="$finalize_command $qarg" + continue + ;; + shrext) + shrext_cmds="$arg" + prev= + continue + ;; + *) + eval "$prev=\"\$arg\"" + prev= + continue + ;; + esac + fi # test -n "$prev" + + prevarg="$arg" + + case $arg in + -all-static) + if test -n "$link_static_flag"; then + compile_command="$compile_command $link_static_flag" + finalize_command="$finalize_command $link_static_flag" + fi + continue + ;; + + -allow-undefined) + # FIXME: remove this flag sometime in the future. + $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2 + continue + ;; + + -avoid-version) + avoid_version=yes + continue + ;; + + -dlopen) + prev=dlfiles + continue + ;; + + -dlpreopen) + prev=dlprefiles + continue + ;; + + -export-dynamic) + export_dynamic=yes + continue + ;; + + -export-symbols | -export-symbols-regex) + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + $echo "$modename: more than one -exported-symbols argument is not allowed" + exit $EXIT_FAILURE + fi + if test "X$arg" = "X-export-symbols"; then + prev=expsyms + else + prev=expsyms_regex + fi + continue + ;; + + -inst-prefix-dir) + prev=inst_prefix + continue + ;; + + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* + # so, if we see these flags be careful not to treat them like -L + -L[A-Z][A-Z]*:*) + case $with_gcc/$host in + no/*-*-irix* | /*-*-irix*) + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + ;; + esac + continue + ;; + + -L*) + dir=`$echo "X$arg" | $Xsed -e 's/^-L//'` + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2 + exit $EXIT_FAILURE + fi + dir="$absdir" + ;; + esac + case "$deplibs " in + *" -L$dir "*) ;; + *) + deplibs="$deplibs -L$dir" + lib_search_path="$lib_search_path $dir" + ;; + esac + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) + case :$dllsearchpath: in + *":$dir:"*) ;; + *) dllsearchpath="$dllsearchpath:$dir";; + esac + ;; + esac + continue + ;; + + -l*) + if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then + case $host in + *-*-cygwin* | *-*-pw32* | *-*-beos*) + # These systems don't actually have a C or math library (as such) + continue + ;; + *-*-mingw* | *-*-os2*) + # These systems don't actually have a C library (as such) + test "X$arg" = "X-lc" && continue + ;; + *-*-openbsd* | *-*-freebsd*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C and math libraries are in the System framework + deplibs="$deplibs -framework System" + continue + esac + elif test "X$arg" = "X-lc_r"; then + case $host in + *-*-openbsd* | *-*-freebsd*) + # Do not include libc_r directly, use -pthread flag. + continue + ;; + esac + fi + deplibs="$deplibs $arg" + continue + ;; + + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe) + deplibs="$deplibs $arg" + continue + ;; + + -module) + module=yes + continue + ;; + + # gcc -m* arguments should be passed to the linker via $compiler_flags + # in order to pass architecture information to the linker + # (e.g. 32 vs 64-bit). This may also be accomplished via -Wl,-mfoo + # but this is not reliable with gcc because gcc may use -mfoo to + # select a different linker, different libraries, etc, while + # -Wl,-mfoo simply passes -mfoo to the linker. + -m*) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + if test "$with_gcc" = "yes" ; then + compiler_flags="$compiler_flags $arg" + fi + continue + ;; + + -shrext) + prev=shrext + continue + ;; + + -no-fast-install) + fast_install=no + continue + ;; + + -no-install) + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) + # The PATH hackery in wrapper scripts is required on Windows + # in order for the loader to find any dlls it needs. + $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2 + $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2 + fast_install=no + ;; + *) no_install=yes ;; + esac + continue + ;; + + -no-undefined) + allow_undefined=no + continue + ;; + + -objectlist) + prev=objectlist + continue + ;; + + -o) prev=output ;; + + -precious-files-regex) + prev=precious_regex + continue + ;; + + -release) + prev=release + continue + ;; + + -rpath) + prev=rpath + continue + ;; + + -R) + prev=xrpath + continue + ;; + + -R*) + dir=`$echo "X$arg" | $Xsed -e 's/^-R//'` + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + $echo "$modename: only absolute run-paths are allowed" 1>&2 + exit $EXIT_FAILURE + ;; + esac + case "$xrpath " in + *" $dir "*) ;; + *) xrpath="$xrpath $dir" ;; + esac + continue + ;; + + -static) + # The effects of -static are defined in a previous loop. + # We used to do the same as -all-static on platforms that + # didn't have a PIC flag, but the assumption that the effects + # would be equivalent was wrong. It would break on at least + # Digital Unix and AIX. + continue + ;; + + -thread-safe) + thread_safe=yes + continue + ;; + + -version-info) + prev=vinfo + continue + ;; + -version-number) + prev=vinfo + vinfo_number=yes + continue + ;; + + -Wc,*) + args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'` + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + case $flag in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + flag="\"$flag\"" + ;; + esac + arg="$arg $wl$flag" + compiler_flags="$compiler_flags $flag" + done + IFS="$save_ifs" + arg=`$echo "X$arg" | $Xsed -e "s/^ //"` + ;; + + -Wl,*) + args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'` + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + case $flag in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + flag="\"$flag\"" + ;; + esac + arg="$arg $wl$flag" + compiler_flags="$compiler_flags $wl$flag" + linker_flags="$linker_flags $flag" + done + IFS="$save_ifs" + arg=`$echo "X$arg" | $Xsed -e "s/^ //"` + ;; + + -Xcompiler) + prev=xcompiler + continue + ;; + + -Xlinker) + prev=xlinker + continue + ;; + + -XCClinker) + prev=xcclinker + continue + ;; + + # Some other compiler flag. + -* | +*) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + ;; + + *.$objext) + # A standard object. + objs="$objs $arg" + ;; + + *.lo) + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + pic_object= + non_pic_object= + + # Read the .lo file + # If there is no directory component, then add one. + case $arg in + */* | *\\*) . $arg ;; + *) . ./$arg ;; + esac + + if test -z "$pic_object" || \ + test -z "$non_pic_object" || + test "$pic_object" = none && \ + test "$non_pic_object" = none; then + $echo "$modename: cannot find name of object for \`$arg'" 1>&2 + exit $EXIT_FAILURE + fi + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + dlfiles="$dlfiles $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + dlprefiles="$dlprefiles $pic_object" + prev= + fi + + # A PIC object. + libobjs="$libobjs $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + non_pic_objects="$non_pic_objects $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + fi + else + # Only an error if not doing a dry-run. + if test -z "$run"; then + $echo "$modename: \`$arg' is not a valid libtool object" 1>&2 + exit $EXIT_FAILURE + else + # Dry-run case. + + # Extract subdirectory from the argument. + xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` + if test "X$xdir" = "X$arg"; then + xdir= + else + xdir="$xdir/" + fi + + pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"` + non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"` + libobjs="$libobjs $pic_object" + non_pic_objects="$non_pic_objects $non_pic_object" + fi + fi + ;; + + *.$libext) + # An archive. + deplibs="$deplibs $arg" + old_deplibs="$old_deplibs $arg" + continue + ;; + + *.la) + # A libtool-controlled library. + + if test "$prev" = dlfiles; then + # This library was specified with -dlopen. + dlfiles="$dlfiles $arg" + prev= + elif test "$prev" = dlprefiles; then + # The library was specified with -dlpreopen. + dlprefiles="$dlprefiles $arg" + prev= + else + deplibs="$deplibs $arg" + fi + continue + ;; + + # Some other compiler argument. + *) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + arg="\"$arg\"" + ;; + esac + ;; + esac # arg + + # Now actually substitute the argument into the commands. + if test -n "$arg"; then + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + fi + done # argument parsing loop + + if test -n "$prev"; then + $echo "$modename: the \`$prevarg' option requires an argument" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then + eval arg=\"$export_dynamic_flag_spec\" + compile_command="$compile_command $arg" + finalize_command="$finalize_command $arg" + fi + + oldlibs= + # calculate the name of the file, without its directory + outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'` + libobjs_save="$libobjs" + + if test -n "$shlibpath_var"; then + # get the directories listed in $shlibpath_var + eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\` + else + shlib_search_path= + fi + eval sys_lib_search_path=\"$sys_lib_search_path_spec\" + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" + + output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'` + if test "X$output_objdir" = "X$output"; then + output_objdir="$objdir" + else + output_objdir="$output_objdir/$objdir" + fi + # Create the object directory. + if test ! -d "$output_objdir"; then + $show "$mkdir $output_objdir" + $run $mkdir $output_objdir + status=$? + if test "$status" -ne 0 && test ! -d "$output_objdir"; then + exit $status + fi + fi + + # Determine the type of output + case $output in + "") + $echo "$modename: you must specify an output file" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + *.$libext) linkmode=oldlib ;; + *.lo | *.$objext) linkmode=obj ;; + *.la) linkmode=lib ;; + *) linkmode=prog ;; # Anything else should be a program. + esac + + case $host in + *cygwin* | *mingw* | *pw32*) + # don't eliminate duplications in $postdeps and $predeps + duplicate_compiler_generated_deps=yes + ;; + *) + duplicate_compiler_generated_deps=$duplicate_deps + ;; + esac + specialdeplibs= + + libs= + # Find all interdependent deplibs by searching for libraries + # that are linked more than once (e.g. -la -lb -la) + for deplib in $deplibs; do + if test "X$duplicate_deps" = "Xyes" ; then + case "$libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + libs="$libs $deplib" + done + + if test "$linkmode" = lib; then + libs="$predeps $libs $compiler_lib_search_path $postdeps" + + # Compute libraries that are listed more than once in $predeps + # $postdeps and mark them as special (i.e., whose duplicates are + # not to be eliminated). + pre_post_deps= + if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then + for pre_post_dep in $predeps $postdeps; do + case "$pre_post_deps " in + *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;; + esac + pre_post_deps="$pre_post_deps $pre_post_dep" + done + fi + pre_post_deps= + fi + + deplibs= + newdependency_libs= + newlib_search_path= + need_relink=no # whether we're linking any uninstalled libtool libraries + notinst_deplibs= # not-installed libtool libraries + notinst_path= # paths that contain not-installed libtool libraries + case $linkmode in + lib) + passes="conv link" + for file in $dlfiles $dlprefiles; do + case $file in + *.la) ;; + *) + $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2 + exit $EXIT_FAILURE + ;; + esac + done + ;; + prog) + compile_deplibs= + finalize_deplibs= + alldeplibs=no + newdlfiles= + newdlprefiles= + passes="conv scan dlopen dlpreopen link" + ;; + *) passes="conv" + ;; + esac + for pass in $passes; do + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan"; then + libs="$deplibs" + deplibs= + fi + if test "$linkmode" = prog; then + case $pass in + dlopen) libs="$dlfiles" ;; + dlpreopen) libs="$dlprefiles" ;; + link) libs="$deplibs %DEPLIBS% $dependency_libs" ;; + esac + fi + if test "$pass" = dlopen; then + # Collect dlpreopened libraries + save_deplibs="$deplibs" + deplibs= + fi + for deplib in $libs; do + lib= + found=no + case $deplib in + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + fi + continue + ;; + -l*) + if test "$linkmode" != lib && test "$linkmode" != prog; then + $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2 + continue + fi + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + name=`$echo "X$deplib" | $Xsed -e 's/^-l//'` + for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do + for search_ext in .la $std_shrext .so .a; do + # Search the libtool library + lib="$searchdir/lib${name}${search_ext}" + if test -f "$lib"; then + if test "$search_ext" = ".la"; then + found=yes + else + found=no + fi + break 2 + fi + done + done + if test "$found" != yes; then + # deplib doesn't seem to be a libtool library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + else # deplib is a libtool library + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, + # We need to do some special things here, and not later. + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $deplib "*) + if (${SED} -e '2q' $lib | + grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + library_names= + old_library= + case $lib in + */* | *\\*) . $lib ;; + *) . ./$lib ;; + esac + for l in $old_library $library_names; do + ll="$l" + done + if test "X$ll" = "X$old_library" ; then # only static version available + found=no + ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'` + test "X$ladir" = "X$lib" && ladir="." + lib=$ladir/$old_library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + fi + fi + ;; + *) ;; + esac + fi + fi + ;; # -l + -L*) + case $linkmode in + lib) + deplibs="$deplib $deplibs" + test "$pass" = conv && continue + newdependency_libs="$deplib $newdependency_libs" + newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'` + ;; + prog) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + if test "$pass" = scan; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'` + ;; + *) + $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2 + ;; + esac # linkmode + continue + ;; # -L + -R*) + if test "$pass" = link; then + dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'` + # Make sure the xrpath contains only unique directories. + case "$xrpath " in + *" $dir "*) ;; + *) xrpath="$xrpath $dir" ;; + esac + fi + deplibs="$deplib $deplibs" + continue + ;; + *.la) lib="$deplib" ;; + *.$libext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + case $linkmode in + lib) + if test "$deplibs_check_method" != pass_all; then + $echo + $echo "*** Warning: Trying to link with static lib archive $deplib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have" + $echo "*** because the file extensions .$libext of this argument makes me believe" + $echo "*** that it is just a static archive that I should not used here." + else + $echo + $echo "*** Warning: Linking the shared library $output against the" + $echo "*** static library $deplib is not portable!" + deplibs="$deplib $deplibs" + fi + continue + ;; + prog) + if test "$pass" != link; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + continue + ;; + esac # linkmode + ;; # *.$libext + *.lo | *.$objext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + elif test "$linkmode" = prog; then + if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then + # If there is no dlopen support or we're linking statically, + # we need to preload. + newdlprefiles="$newdlprefiles $deplib" + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + newdlfiles="$newdlfiles $deplib" + fi + fi + continue + ;; + %DEPLIBS%) + alldeplibs=yes + continue + ;; + esac # case $deplib + if test "$found" = yes || test -f "$lib"; then : + else + $echo "$modename: cannot find the library \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + + # Check to see that this really is a libtool archive. + if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then : + else + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + + ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'` + test "X$ladir" = "X$lib" && ladir="." + + dlname= + dlopen= + dlpreopen= + libdir= + library_names= + old_library= + # If the library was installed with an old release of libtool, + # it will not redefine variables installed, or shouldnotlink + installed=yes + shouldnotlink=no + + # Read the .la file + case $lib in + */* | *\\*) . $lib ;; + *) . ./$lib ;; + esac + + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan" || + { test "$linkmode" != prog && test "$linkmode" != lib; }; then + test -n "$dlopen" && dlfiles="$dlfiles $dlopen" + test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen" + fi + + if test "$pass" = conv; then + # Only check for convenience libraries + deplibs="$lib $deplibs" + if test -z "$libdir"; then + if test -z "$old_library"; then + $echo "$modename: cannot find name of link library for \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + # It is a libtool convenience library, so add in its objects. + convenience="$convenience $ladir/$objdir/$old_library" + old_convenience="$old_convenience $ladir/$objdir/$old_library" + tmp_libs= + for deplib in $dependency_libs; do + deplibs="$deplib $deplibs" + if test "X$duplicate_deps" = "Xyes" ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + tmp_libs="$tmp_libs $deplib" + done + elif test "$linkmode" != prog && test "$linkmode" != lib; then + $echo "$modename: \`$lib' is not a convenience library" 1>&2 + exit $EXIT_FAILURE + fi + continue + fi # $pass = conv + + + # Get the name of the library we link against. + linklib= + for l in $old_library $library_names; do + linklib="$l" + done + if test -z "$linklib"; then + $echo "$modename: cannot find name of link library for \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + + # This library was specified with -dlopen. + if test "$pass" = dlopen; then + if test -z "$libdir"; then + $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + if test -z "$dlname" || + test "$dlopen_support" != yes || + test "$build_libtool_libs" = no; then + # If there is no dlname, no dlopen support or we're linking + # statically, we need to preload. We also need to preload any + # dependent libraries so libltdl's deplib preloader doesn't + # bomb out in the load deplibs phase. + dlprefiles="$dlprefiles $lib $dependency_libs" + else + newdlfiles="$newdlfiles $lib" + fi + continue + fi # $pass = dlopen + + # We need an absolute path. + case $ladir in + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; + *) + abs_ladir=`cd "$ladir" && pwd` + if test -z "$abs_ladir"; then + $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2 + $echo "$modename: passing it literally to the linker, although it might fail" 1>&2 + abs_ladir="$ladir" + fi + ;; + esac + laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'` + + # Find the relevant object directory and library name. + if test "X$installed" = Xyes; then + if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then + $echo "$modename: warning: library \`$lib' was moved." 1>&2 + dir="$ladir" + absdir="$abs_ladir" + libdir="$abs_ladir" + else + dir="$libdir" + absdir="$libdir" + fi + else + dir="$ladir/$objdir" + absdir="$abs_ladir/$objdir" + # Remove this search path later + notinst_path="$notinst_path $abs_ladir" + fi # $installed = yes + name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'` + + # This library was specified with -dlpreopen. + if test "$pass" = dlpreopen; then + if test -z "$libdir"; then + $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2 + exit $EXIT_FAILURE + fi + # Prefer using a static library (so that no silly _DYNAMIC symbols + # are required to link). + if test -n "$old_library"; then + newdlprefiles="$newdlprefiles $dir/$old_library" + # Otherwise, use the dlname, so that lt_dlopen finds it. + elif test -n "$dlname"; then + newdlprefiles="$newdlprefiles $dir/$dlname" + else + newdlprefiles="$newdlprefiles $dir/$linklib" + fi + fi # $pass = dlpreopen + + if test -z "$libdir"; then + # Link the convenience library + if test "$linkmode" = lib; then + deplibs="$dir/$old_library $deplibs" + elif test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$dir/$old_library $compile_deplibs" + finalize_deplibs="$dir/$old_library $finalize_deplibs" + else + deplibs="$lib $deplibs" # used for prog,scan pass + fi + continue + fi + + + if test "$linkmode" = prog && test "$pass" != link; then + newlib_search_path="$newlib_search_path $ladir" + deplibs="$lib $deplibs" + + linkalldeplibs=no + if test "$link_all_deplibs" != no || test -z "$library_names" || + test "$build_libtool_libs" = no; then + linkalldeplibs=yes + fi + + tmp_libs= + for deplib in $dependency_libs; do + case $deplib in + -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test + esac + # Need to link against all dependency_libs? + if test "$linkalldeplibs" = yes; then + deplibs="$deplib $deplibs" + else + # Need to hardcode shared library paths + # or/and link against static libraries + newdependency_libs="$deplib $newdependency_libs" + fi + if test "X$duplicate_deps" = "Xyes" ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + tmp_libs="$tmp_libs $deplib" + done # for deplib + continue + fi # $linkmode = prog... + + if test "$linkmode,$pass" = "prog,link"; then + if test -n "$library_names" && + { test "$prefer_static_libs" = no || test -z "$old_library"; }; then + # We need to hardcode the library path + if test -n "$shlibpath_var"; then + # Make sure the rpath contains only unique directories. + case "$temp_rpath " in + *" $dir "*) ;; + *" $absdir "*) ;; + *) temp_rpath="$temp_rpath $dir" ;; + esac + fi + + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) compile_rpath="$compile_rpath $absdir" + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" + esac + ;; + esac + fi # $linkmode,$pass = prog,link... + + if test "$alldeplibs" = yes && + { test "$deplibs_check_method" = pass_all || + { test "$build_libtool_libs" = yes && + test -n "$library_names"; }; }; then + # We only need to search for static libraries + continue + fi + fi + + link_static=no # Whether the deplib will be linked statically + if test -n "$library_names" && + { test "$prefer_static_libs" = no || test -z "$old_library"; }; then + if test "$installed" = no; then + notinst_deplibs="$notinst_deplibs $lib" + need_relink=yes + fi + # This is a shared library + + # Warn about portability, can't link against -module's on + # some systems (darwin) + if test "$shouldnotlink" = yes && test "$pass" = link ; then + $echo + if test "$linkmode" = prog; then + $echo "*** Warning: Linking the executable $output against the loadable module" + else + $echo "*** Warning: Linking the shared library $output against the loadable module" + fi + $echo "*** $linklib is not portable!" + fi + if test "$linkmode" = lib && + test "$hardcode_into_libs" = yes; then + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) compile_rpath="$compile_rpath $absdir" + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" + esac + ;; + esac + fi + + if test -n "$old_archive_from_expsyms_cmds"; then + # figure out the soname + set dummy $library_names + realname="$2" + shift; shift + libname=`eval \\$echo \"$libname_spec\"` + # use dlname if we got it. it's perfectly good, no? + if test -n "$dlname"; then + soname="$dlname" + elif test -n "$soname_spec"; then + # bleh windows + case $host in + *cygwin* | mingw*) + major=`expr $current - $age` + versuffix="-$major" + ;; + esac + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + + # Make a new name for the extract_expsyms_cmds to use + soroot="$soname" + soname=`$echo $soroot | ${SED} -e 's/^.*\///'` + newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a" + + # If the library has no export list, then create one now + if test -f "$output_objdir/$soname-def"; then : + else + $show "extracting exported symbol list from \`$soname'" + save_ifs="$IFS"; IFS='~' + cmds=$extract_expsyms_cmds + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + + # Create $newlib + if test -f "$output_objdir/$newlib"; then :; else + $show "generating import library for \`$soname'" + save_ifs="$IFS"; IFS='~' + cmds=$old_archive_from_expsyms_cmds + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + # make sure the library variables are pointing to the new library + dir=$output_objdir + linklib=$newlib + fi # test -n "$old_archive_from_expsyms_cmds" + + if test "$linkmode" = prog || test "$mode" != relink; then + add_shlibpath= + add_dir= + add= + lib_linked=yes + case $hardcode_action in + immediate | unsupported) + if test "$hardcode_direct" = no; then + add="$dir/$linklib" + case $host in + *-*-sco3.2v5* ) add_dir="-L$dir" ;; + *-*-darwin* ) + # if the lib is a module then we can not link against + # it, someone is ignoring the new warnings I added + if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then + $echo "** Warning, lib $linklib is a module, not a shared library" + if test -z "$old_library" ; then + $echo + $echo "** And there doesn't seem to be a static archive available" + $echo "** The link will probably fail, sorry" + else + add="$dir/$old_library" + fi + fi + esac + elif test "$hardcode_minus_L" = no; then + case $host in + *-*-sunos*) add_shlibpath="$dir" ;; + esac + add_dir="-L$dir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = no; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + relink) + if test "$hardcode_direct" = yes; then + add="$dir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$dir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case "$libdir" in + [\\/]*) + add_dir="$add_dir -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + *) lib_linked=no ;; + esac + + if test "$lib_linked" != yes; then + $echo "$modename: configuration error: unsupported hardcode properties" + exit $EXIT_FAILURE + fi + + if test -n "$add_shlibpath"; then + case :$compile_shlibpath: in + *":$add_shlibpath:"*) ;; + *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;; + esac + fi + if test "$linkmode" = prog; then + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" + test -n "$add" && compile_deplibs="$add $compile_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + if test "$hardcode_direct" != yes && \ + test "$hardcode_minus_L" != yes && \ + test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; + esac + fi + fi + fi + + if test "$linkmode" = prog || test "$mode" = relink; then + add_shlibpath= + add_dir= + add= + # Finalize command for both is simple: just hardcode it. + if test "$hardcode_direct" = yes; then + add="$libdir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$libdir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;; + esac + add="-l$name" + elif test "$hardcode_automatic" = yes; then + if test -n "$inst_prefix_dir" && + test -f "$inst_prefix_dir$libdir/$linklib" ; then + add="$inst_prefix_dir$libdir/$linklib" + else + add="$libdir/$linklib" + fi + else + # We cannot seem to hardcode it, guess we'll fake it. + add_dir="-L$libdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case "$libdir" in + [\\/]*) + add_dir="$add_dir -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + fi + + if test "$linkmode" = prog; then + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" + test -n "$add" && finalize_deplibs="$add $finalize_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + fi + fi + elif test "$linkmode" = prog; then + # Here we assume that one of hardcode_direct or hardcode_minus_L + # is not unsupported. This is valid on all known static and + # shared platforms. + if test "$hardcode_direct" != unsupported; then + test -n "$old_library" && linklib="$old_library" + compile_deplibs="$dir/$linklib $compile_deplibs" + finalize_deplibs="$dir/$linklib $finalize_deplibs" + else + compile_deplibs="-l$name -L$dir $compile_deplibs" + finalize_deplibs="-l$name -L$dir $finalize_deplibs" + fi + elif test "$build_libtool_libs" = yes; then + # Not a shared library + if test "$deplibs_check_method" != pass_all; then + # We're trying link a shared library against a static one + # but the system doesn't support it. + + # Just print a warning and add the library to dependency_libs so + # that the program can be linked against the static library. + $echo + $echo "*** Warning: This system can not link to static lib archive $lib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have." + if test "$module" = yes; then + $echo "*** But as you try to build a module library, libtool will still create " + $echo "*** a static module, that should work as long as the dlopening application" + $echo "*** is linked with the -dlopen flag to resolve symbols at runtime." + if test -z "$global_symbol_pipe"; then + $echo + $echo "*** However, this would only work if libtool was able to extract symbol" + $echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + $echo "*** not find such a program. So, this module is probably useless." + $echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + else + convenience="$convenience $dir/$old_library" + old_convenience="$old_convenience $dir/$old_library" + deplibs="$dir/$old_library $deplibs" + link_static=yes + fi + fi # link shared/static library? + + if test "$linkmode" = lib; then + if test -n "$dependency_libs" && + { test "$hardcode_into_libs" != yes || + test "$build_old_libs" = yes || + test "$link_static" = yes; }; then + # Extract -R from dependency_libs + temp_deplibs= + for libdir in $dependency_libs; do + case $libdir in + -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'` + case " $xrpath " in + *" $temp_xrpath "*) ;; + *) xrpath="$xrpath $temp_xrpath";; + esac;; + *) temp_deplibs="$temp_deplibs $libdir";; + esac + done + dependency_libs="$temp_deplibs" + fi + + newlib_search_path="$newlib_search_path $absdir" + # Link against this library + test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" + # ... and its dependency_libs + tmp_libs= + for deplib in $dependency_libs; do + newdependency_libs="$deplib $newdependency_libs" + if test "X$duplicate_deps" = "Xyes" ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;; + esac + fi + tmp_libs="$tmp_libs $deplib" + done + + if test "$link_all_deplibs" != no; then + # Add the search paths of all dependency libraries + for deplib in $dependency_libs; do + case $deplib in + -L*) path="$deplib" ;; + *.la) + dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'` + test "X$dir" = "X$deplib" && dir="." + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2 + absdir="$dir" + fi + ;; + esac + if grep "^installed=no" $deplib > /dev/null; then + path="$absdir/$objdir" + else + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + if test -z "$libdir"; then + $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + if test "$absdir" != "$libdir"; then + $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2 + fi + path="$absdir" + fi + depdepl= + case $host in + *-*-darwin*) + # we do not want to link against static libs, + # but need to link against shared + eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` + if test -n "$deplibrary_names" ; then + for tmp in $deplibrary_names ; do + depdepl=$tmp + done + if test -f "$path/$depdepl" ; then + depdepl="$path/$depdepl" + fi + # do not add paths which are already there + case " $newlib_search_path " in + *" $path "*) ;; + *) newlib_search_path="$newlib_search_path $path";; + esac + fi + path="" + ;; + *) + path="-L$path" + ;; + esac + ;; + -l*) + case $host in + *-*-darwin*) + # Again, we only want to link against shared libraries + eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"` + for tmp in $newlib_search_path ; do + if test -f "$tmp/lib$tmp_libs.dylib" ; then + eval depdepl="$tmp/lib$tmp_libs.dylib" + break + fi + done + path="" + ;; + *) continue ;; + esac + ;; + *) continue ;; + esac + case " $deplibs " in + *" $depdepl "*) ;; + *) deplibs="$depdepl $deplibs" ;; + esac + case " $deplibs " in + *" $path "*) ;; + *) deplibs="$deplibs $path" ;; + esac + done + fi # link_all_deplibs != no + fi # linkmode = lib + done # for deplib in $libs + dependency_libs="$newdependency_libs" + if test "$pass" = dlpreopen; then + # Link the dlpreopened libraries before other libraries + for deplib in $save_deplibs; do + deplibs="$deplib $deplibs" + done + fi + if test "$pass" != dlopen; then + if test "$pass" != conv; then + # Make sure lib_search_path contains only unique directories. + lib_search_path= + for dir in $newlib_search_path; do + case "$lib_search_path " in + *" $dir "*) ;; + *) lib_search_path="$lib_search_path $dir" ;; + esac + done + newlib_search_path= + fi + + if test "$linkmode,$pass" != "prog,link"; then + vars="deplibs" + else + vars="compile_deplibs finalize_deplibs" + fi + for var in $vars dependency_libs; do + # Add libraries to $var in reverse order + eval tmp_libs=\"\$$var\" + new_libs= + for deplib in $tmp_libs; do + # FIXME: Pedantically, this is the right thing to do, so + # that some nasty dependency loop isn't accidentally + # broken: + #new_libs="$deplib $new_libs" + # Pragmatically, this seems to cause very few problems in + # practice: + case $deplib in + -L*) new_libs="$deplib $new_libs" ;; + -R*) ;; + *) + # And here is the reason: when a library appears more + # than once as an explicit dependence of a library, or + # is implicitly linked in more than once by the + # compiler, it is considered special, and multiple + # occurrences thereof are not removed. Compare this + # with having the same library being listed as a + # dependency of multiple other libraries: in this case, + # we know (pedantically, we assume) the library does not + # need to be listed more than once, so we keep only the + # last copy. This is not always right, but it is rare + # enough that we require users that really mean to play + # such unportable linking tricks to link the library + # using -Wl,-lname, so that libtool does not consider it + # for duplicate removal. + case " $specialdeplibs " in + *" $deplib "*) new_libs="$deplib $new_libs" ;; + *) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs="$deplib $new_libs" ;; + esac + ;; + esac + ;; + esac + done + tmp_libs= + for deplib in $new_libs; do + case $deplib in + -L*) + case " $tmp_libs " in + *" $deplib "*) ;; + *) tmp_libs="$tmp_libs $deplib" ;; + esac + ;; + *) tmp_libs="$tmp_libs $deplib" ;; + esac + done + eval $var=\"$tmp_libs\" + done # for var + fi + # Last step: remove runtime libs from dependency_libs + # (they stay in deplibs) + tmp_libs= + for i in $dependency_libs ; do + case " $predeps $postdeps $compiler_lib_search_path " in + *" $i "*) + i="" + ;; + esac + if test -n "$i" ; then + tmp_libs="$tmp_libs $i" + fi + done + dependency_libs=$tmp_libs + done # for pass + if test "$linkmode" = prog; then + dlfiles="$newdlfiles" + dlprefiles="$newdlprefiles" + fi + + case $linkmode in + oldlib) + if test -n "$deplibs"; then + $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 + fi + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2 + fi + + if test -n "$rpath"; then + $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2 + fi + + if test -n "$xrpath"; then + $echo "$modename: warning: \`-R' is ignored for archives" 1>&2 + fi + + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for archives" 1>&2 + fi + + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2 + fi + + # Now set the variables for building old libraries. + build_libtool_libs=no + oldlibs="$output" + objs="$objs$old_deplibs" + ;; + + lib) + # Make sure we only generate libraries of the form `libNAME.la'. + case $outputname in + lib*) + name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'` + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + ;; + *) + if test "$module" = no; then + $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + if test "$need_lib_prefix" != no; then + # Add the "lib" prefix for modules if required + name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'` + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + else + libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'` + fi + ;; + esac + + if test -n "$objs"; then + if test "$deplibs_check_method" != pass_all; then + $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1 + exit $EXIT_FAILURE + else + $echo + $echo "*** Warning: Linking the shared library $output against the non-libtool" + $echo "*** objects $objs is not portable!" + libobjs="$libobjs $objs" + fi + fi + + if test "$dlself" != no; then + $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2 + fi + + set dummy $rpath + if test "$#" -gt 2; then + $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2 + fi + install_libdir="$2" + + oldlibs= + if test -z "$rpath"; then + if test "$build_libtool_libs" = yes; then + # Building a libtool convenience library. + # Some compilers have problems with a `.al' extension so + # convenience libraries should have the same extension an + # archive normally would. + oldlibs="$output_objdir/$libname.$libext $oldlibs" + build_libtool_libs=convenience + build_old_libs=yes + fi + + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2 + fi + else + + # Parse the version information argument. + save_ifs="$IFS"; IFS=':' + set dummy $vinfo 0 0 0 + IFS="$save_ifs" + + if test -n "$8"; then + $echo "$modename: too many parameters to \`-version-info'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # convert absolute version numbers to libtool ages + # this retains compatibility with .la files and attempts + # to make the code below a bit more comprehensible + + case $vinfo_number in + yes) + number_major="$2" + number_minor="$3" + number_revision="$4" + # + # There are really only two kinds -- those that + # use the current revision as the major version + # and those that subtract age and use age as + # a minor version. But, then there is irix + # which has an extra 1 added just for fun + # + case $version_type in + darwin|linux|osf|windows) + current=`expr $number_major + $number_minor` + age="$number_minor" + revision="$number_revision" + ;; + freebsd-aout|freebsd-elf|sunos) + current="$number_major" + revision="$number_minor" + age="0" + ;; + irix|nonstopux) + current=`expr $number_major + $number_minor - 1` + age="$number_minor" + revision="$number_minor" + ;; + esac + ;; + no) + current="$2" + revision="$3" + age="$4" + ;; + esac + + # Check that each of the things are valid numbers. + case $current in + [0-9]*) ;; + *) + $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + case $revision in + [0-9]*) ;; + *) + $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + case $age in + [0-9]*) ;; + *) + $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + if test "$age" -gt "$current"; then + $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2 + $echo "$modename: \`$vinfo' is not valid version information" 1>&2 + exit $EXIT_FAILURE + fi + + # Calculate the version variables. + major= + versuffix= + verstring= + case $version_type in + none) ;; + + darwin) + # Like Linux, but with the current version available in + # verstring for coding it into the library header + major=.`expr $current - $age` + versuffix="$major.$age.$revision" + # Darwin ld doesn't like 0 for these options... + minor_current=`expr $current + 1` + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" + ;; + + freebsd-aout) + major=".$current" + versuffix=".$current.$revision"; + ;; + + freebsd-elf) + major=".$current" + versuffix=".$current"; + ;; + + irix | nonstopux) + major=`expr $current - $age + 1` + + case $version_type in + nonstopux) verstring_prefix=nonstopux ;; + *) verstring_prefix=sgi ;; + esac + verstring="$verstring_prefix$major.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$revision + while test "$loop" -ne 0; do + iface=`expr $revision - $loop` + loop=`expr $loop - 1` + verstring="$verstring_prefix$major.$iface:$verstring" + done + + # Before this point, $major must not contain `.'. + major=.$major + versuffix="$major.$revision" + ;; + + linux) + major=.`expr $current - $age` + versuffix="$major.$age.$revision" + ;; + + osf) + major=.`expr $current - $age` + versuffix=".$current.$age.$revision" + verstring="$current.$age.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$age + while test "$loop" -ne 0; do + iface=`expr $current - $loop` + loop=`expr $loop - 1` + verstring="$verstring:${iface}.0" + done + + # Make executables depend on our current version. + verstring="$verstring:${current}.0" + ;; + + sunos) + major=".$current" + versuffix=".$current.$revision" + ;; + + windows) + # Use '-' rather than '.', since we only want one + # extension on DOS 8.3 filesystems. + major=`expr $current - $age` + versuffix="-$major" + ;; + + *) + $echo "$modename: unknown library version type \`$version_type'" 1>&2 + $echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 + exit $EXIT_FAILURE + ;; + esac + + # Clear the version info if we defaulted, and they specified a release. + if test -z "$vinfo" && test -n "$release"; then + major= + case $version_type in + darwin) + # we can't check for "0.0" in archive_cmds due to quoting + # problems, so we reset it completely + verstring= + ;; + *) + verstring="0.0" + ;; + esac + if test "$need_version" = no; then + versuffix= + else + versuffix=".0.0" + fi + fi + + # Remove version info from name if versioning should be avoided + if test "$avoid_version" = yes && test "$need_version" = no; then + major= + versuffix= + verstring="" + fi + + # Check to see if the archive will have undefined symbols. + if test "$allow_undefined" = yes; then + if test "$allow_undefined_flag" = unsupported; then + $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2 + build_libtool_libs=no + build_old_libs=yes + fi + else + # Don't allow undefined symbols. + allow_undefined_flag="$no_undefined_flag" + fi + fi + + if test "$mode" != relink; then + # Remove our outputs, but don't remove object files since they + # may have been created when compiling PIC objects. + removelist= + tempremovelist=`$echo "$output_objdir/*"` + for p in $tempremovelist; do + case $p in + *.$objext) + ;; + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) + if test "X$precious_files_regex" != "X"; then + if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 + then + continue + fi + fi + removelist="$removelist $p" + ;; + *) ;; + esac + done + if test -n "$removelist"; then + $show "${rm}r $removelist" + $run ${rm}r $removelist + fi + fi + + # Now set the variables for building old libraries. + if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then + oldlibs="$oldlibs $output_objdir/$libname.$libext" + + # Transform .lo files to .o files. + oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP` + fi + + # Eliminate all temporary directories. + for path in $notinst_path; do + lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'` + deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'` + dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'` + done + + if test -n "$xrpath"; then + # If the user specified any rpath flags, then add them. + temp_xrpath= + for libdir in $xrpath; do + temp_xrpath="$temp_xrpath -R$libdir" + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" ;; + esac + done + if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then + dependency_libs="$temp_xrpath $dependency_libs" + fi + fi + + # Make sure dlfiles contains only unique files that won't be dlpreopened + old_dlfiles="$dlfiles" + dlfiles= + for lib in $old_dlfiles; do + case " $dlprefiles $dlfiles " in + *" $lib "*) ;; + *) dlfiles="$dlfiles $lib" ;; + esac + done + + # Make sure dlprefiles contains only unique files + old_dlprefiles="$dlprefiles" + dlprefiles= + for lib in $old_dlprefiles; do + case "$dlprefiles " in + *" $lib "*) ;; + *) dlprefiles="$dlprefiles $lib" ;; + esac + done + + if test "$build_libtool_libs" = yes; then + if test -n "$rpath"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*) + # these systems don't actually have a c library (as such)! + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C library is in the System framework + deplibs="$deplibs -framework System" + ;; + *-*-netbsd*) + # Don't link with libc until the a.out ld.so is fixed. + ;; + *-*-openbsd* | *-*-freebsd*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *) + # Add libc to deplibs on all other systems if necessary. + if test "$build_libtool_need_lc" = "yes"; then + deplibs="$deplibs -lc" + fi + ;; + esac + fi + + # Transform deplibs into only deplibs that can be linked in shared. + name_save=$name + libname_save=$libname + release_save=$release + versuffix_save=$versuffix + major_save=$major + # I'm not sure if I'm treating the release correctly. I think + # release should show up in the -l (ie -lgmp5) so we don't want to + # add it in twice. Is that correct? + release="" + versuffix="" + major="" + newdeplibs= + droppeddeps=no + case $deplibs_check_method in + pass_all) + # Don't check for shared/static. Everything works. + # This might be a little naive. We might want to check + # whether the library exists or not. But this is on + # osf3 & osf4 and I'm not really sure... Just + # implementing what was already the behavior. + newdeplibs=$deplibs + ;; + test_compile) + # This code stresses the "libraries are programs" paradigm to its + # limits. Maybe even breaks it. We compile a program, linking it + # against the deplibs as a proxy for the library. Then we can check + # whether they linked in statically or dynamically with ldd. + $rm conftest.c + cat > conftest.c </dev/null` + for potent_lib in $potential_libs; do + # Follow soft links. + if ls -lLd "$potent_lib" 2>/dev/null \ + | grep " -> " >/dev/null; then + continue + fi + # The statement above tries to avoid entering an + # endless loop below, in case of cyclic links. + # We might still enter an endless loop, since a link + # loop can be closed while we follow links, + # but so what? + potlib="$potent_lib" + while test -h "$potlib" 2>/dev/null; do + potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` + case $potliblink in + [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; + *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";; + esac + done + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \ + | ${SED} 10q \ + | $EGREP "$file_magic_regex" > /dev/null; then + newdeplibs="$newdeplibs $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + $echo + $echo "*** Warning: linker path does not have real file for library $a_deplib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have" + $echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $echo "*** with $libname but no candidates were found. (...for file magic test)" + else + $echo "*** with $libname and none of the candidates passed a file format test" + $echo "*** using a file magic. Last file checked: $potlib" + fi + fi + else + # Add a -L argument. + newdeplibs="$newdeplibs $a_deplib" + fi + done # Gone through all deplibs. + ;; + match_pattern*) + set dummy $deplibs_check_method + match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"` + for a_deplib in $deplibs; do + name="`expr $a_deplib : '-l\(.*\)'`" + # If $name is empty we are operating on a -L argument. + if test -n "$name" && test "$name" != "0"; then + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $a_deplib "*) + newdeplibs="$newdeplibs $a_deplib" + a_deplib="" + ;; + esac + fi + if test -n "$a_deplib" ; then + libname=`eval \\$echo \"$libname_spec\"` + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do + potential_libs=`ls $i/$libname[.-]* 2>/dev/null` + for potent_lib in $potential_libs; do + potlib="$potent_lib" # see symlink-check above in file_magic test + if eval $echo \"$potent_lib\" 2>/dev/null \ + | ${SED} 10q \ + | $EGREP "$match_pattern_regex" > /dev/null; then + newdeplibs="$newdeplibs $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + $echo + $echo "*** Warning: linker path does not have real file for library $a_deplib." + $echo "*** I have the capability to make that library automatically link in when" + $echo "*** you link to this library. But I can only do this if you have a" + $echo "*** shared version of the library, which you do not appear to have" + $echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $echo "*** with $libname but no candidates were found. (...for regex pattern test)" + else + $echo "*** with $libname and none of the candidates passed a file format test" + $echo "*** using a regex pattern. Last file checked: $potlib" + fi + fi + else + # Add a -L argument. + newdeplibs="$newdeplibs $a_deplib" + fi + done # Gone through all deplibs. + ;; + none | unknown | *) + newdeplibs="" + tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \ + -e 's/ -[LR][^ ]*//g'` + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + for i in $predeps $postdeps ; do + # can't use Xsed below, because $i might contain '/' + tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"` + done + fi + if $echo "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' \ + | grep . >/dev/null; then + $echo + if test "X$deplibs_check_method" = "Xnone"; then + $echo "*** Warning: inter-library dependencies are not supported in this platform." + else + $echo "*** Warning: inter-library dependencies are not known to be supported." + fi + $echo "*** All declared inter-library dependencies are being dropped." + droppeddeps=yes + fi + ;; + esac + versuffix=$versuffix_save + major=$major_save + release=$release_save + libname=$libname_save + name=$name_save + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'` + ;; + esac + + if test "$droppeddeps" = yes; then + if test "$module" = yes; then + $echo + $echo "*** Warning: libtool could not satisfy all declared inter-library" + $echo "*** dependencies of module $libname. Therefore, libtool will create" + $echo "*** a static module, that should work as long as the dlopening" + $echo "*** application is linked with the -dlopen flag." + if test -z "$global_symbol_pipe"; then + $echo + $echo "*** However, this would only work if libtool was able to extract symbol" + $echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + $echo "*** not find such a program. So, this module is probably useless." + $echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + else + $echo "*** The inter-library dependencies that have been dropped here will be" + $echo "*** automatically added whenever a program is linked with this library" + $echo "*** or is declared to -dlopen it." + + if test "$allow_undefined" = no; then + $echo + $echo "*** Since this library must not contain undefined symbols," + $echo "*** because either the platform does not support them or" + $echo "*** it was explicitly requested with -no-undefined," + $echo "*** libtool will only create a static version of it." + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + fi + fi + # Done checking deplibs! + deplibs=$newdeplibs + fi + + # All the library-specific variables (install_libdir is set above). + library_names= + old_library= + dlname= + + # Test again, we may have decided not to build it any more + if test "$build_libtool_libs" = yes; then + if test "$hardcode_into_libs" = yes; then + # Hardcode the library paths + hardcode_libdirs= + dep_rpath= + rpath="$finalize_rpath" + test "$mode" != relink && rpath="$compile_rpath$rpath" + for libdir in $rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + dep_rpath="$dep_rpath $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) perm_rpath="$perm_rpath $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + if test -n "$hardcode_libdir_flag_spec_ld"; then + eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" + else + eval dep_rpath=\"$hardcode_libdir_flag_spec\" + fi + fi + if test -n "$runpath_var" && test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + rpath="$rpath$dir:" + done + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" + fi + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" + fi + + shlibpath="$finalize_shlibpath" + test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath" + if test -n "$shlibpath"; then + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" + fi + + # Get the real and link names of the library. + eval shared_ext=\"$shrext_cmds\" + eval library_names=\"$library_names_spec\" + set dummy $library_names + realname="$2" + shift; shift + + if test -n "$soname_spec"; then + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + if test -z "$dlname"; then + dlname=$soname + fi + + lib="$output_objdir/$realname" + for link + do + linknames="$linknames $link" + done + + # Use standard objects if they are pic + test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then + $show "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $run $rm $export_symbols + cmds=$export_symbols_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + if len=`expr "X$cmd" : ".*"` && + test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then + $show "$cmd" + $run eval "$cmd" || exit $? + skipped_export=false + else + # The command line is too long to execute in one step. + $show "using reloadable object file for export list..." + skipped_export=: + fi + done + IFS="$save_ifs" + if test -n "$export_symbols_regex"; then + $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\"" + $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + $show "$mv \"${export_symbols}T\" \"$export_symbols\"" + $run eval '$mv "${export_symbols}T" "$export_symbols"' + fi + fi + fi + + if test -n "$export_symbols" && test -n "$include_expsyms"; then + $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"' + fi + + tmp_deplibs= + inst_prefix_arg= + for test_deplib in $deplibs; do + case " $convenience " in + *" $test_deplib "*) ;; + *) + if test -n "$inst_prefix_dir" && (echo "$test_deplib" | grep -- "$inst_prefix_dir" >/dev/null); then + inst_prefix_arg="$test_deplib" + else + tmp_deplibs="$tmp_deplibs $test_deplib" + fi + ;; + esac + done + deplibs="$tmp_deplibs" + if test -n "$inst_prefix_arg"; then + deplibs="$inst_prefix_arg $deplibs" + fi + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + else + gentop="$output_objdir/${outputname}x" + $show "${rm}r $gentop" + $run ${rm}r "$gentop" + $show "$mkdir $gentop" + $run $mkdir "$gentop" + status=$? + if test "$status" -ne 0 && test ! -d "$gentop"; then + exit $status + fi + generated="$generated $gentop" + + for xlib in $convenience; do + # Extract the objects. + case $xlib in + [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;; + *) xabs=`pwd`"/$xlib" ;; + esac + xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'` + xdir="$gentop/$xlib" + + $show "${rm}r $xdir" + $run ${rm}r "$xdir" + $show "$mkdir $xdir" + $run $mkdir "$xdir" + status=$? + if test "$status" -ne 0 && test ! -d "$xdir"; then + exit $status + fi + # We will extract separately just the conflicting names and we will no + # longer touch any unique names. It is faster to leave these extract + # automatically by $AR in one run. + $show "(cd $xdir && $AR x $xabs)" + $run eval "(cd \$xdir && $AR x \$xabs)" || exit $? + if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; renaming object files" 1>&2 + $echo "$modename: warning: to ensure that they will not overwrite" 1>&2 + $AR t "$xabs" | sort | uniq -cd | while read -r count name + do + i=1 + while test "$i" -le "$count" + do + # Put our $i before any first dot (extension) + # Never overwrite any file + name_to="$name" + while test "X$name_to" = "X$name" || test -f "$xdir/$name_to" + do + name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"` + done + $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')" + $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $? + i=`expr $i + 1` + done + done + fi + + libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP` + done + fi + fi + + if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then + eval flag=\"$thread_safe_flag_spec\" + linker_flags="$linker_flags $flag" + fi + + # Make a backup of the uninstalled library when relinking + if test "$mode" = relink; then + $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $? + fi + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + eval test_cmds=\"$module_expsym_cmds\" + cmds=$module_expsym_cmds + else + eval test_cmds=\"$module_cmds\" + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + eval test_cmds=\"$archive_expsym_cmds\" + cmds=$archive_expsym_cmds + else + eval test_cmds=\"$archive_cmds\" + cmds=$archive_cmds + fi + fi + + if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` && + test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then + : + else + # The command line is too long to link in one step, link piecewise. + $echo "creating reloadable object files..." + + # Save the value of $output and $libobjs because we want to + # use them later. If we have whole_archive_flag_spec, we + # want to use save_libobjs as it was before + # whole_archive_flag_spec was expanded, because we can't + # assume the linker understands whole_archive_flag_spec. + # This may have to be revisited, in case too many + # convenience libraries get linked in and end up exceeding + # the spec. + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + fi + save_output=$output + + # Clear the reloadable object creation command queue and + # initialize k to one. + test_cmds= + concat_cmds= + objlist= + delfiles= + last_robj= + k=1 + output=$output_objdir/$save_output-${k}.$objext + # Loop over the list of objects to be linked. + for obj in $save_libobjs + do + eval test_cmds=\"$reload_cmds $objlist $last_robj\" + if test "X$objlist" = X || + { len=`expr "X$test_cmds" : ".*"` && + test "$len" -le "$max_cmd_len"; }; then + objlist="$objlist $obj" + else + # The command $test_cmds is almost too long, add a + # command to the queue. + if test "$k" -eq 1 ; then + # The first file doesn't have a previous command to add. + eval concat_cmds=\"$reload_cmds $objlist $last_robj\" + else + # All subsequent reloadable object files will link in + # the last one created. + eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\" + fi + last_robj=$output_objdir/$save_output-${k}.$objext + k=`expr $k + 1` + output=$output_objdir/$save_output-${k}.$objext + objlist=$obj + len=1 + fi + done + # Handle the remaining objects by creating one last + # reloadable object file. All subsequent reloadable object + # files will link in the last one created. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\" + + if ${skipped_export-false}; then + $show "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $run $rm $export_symbols + libobjs=$output + # Append the command to create the export file. + eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\" + fi + + # Set up a command to remove the reloadale object files + # after they are used. + i=0 + while test "$i" -lt "$k" + do + i=`expr $i + 1` + delfiles="$delfiles $output_objdir/$save_output-${i}.$objext" + done + + $echo "creating a temporary reloadable object file: $output" + + # Loop through the commands generated above and execute them. + save_ifs="$IFS"; IFS='~' + for cmd in $concat_cmds; do + IFS="$save_ifs" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + + libobjs=$output + # Restore the value of output. + output=$save_output + + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + fi + # Expand the library linking commands again to reset the + # value of $libobjs for piecewise linking. + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + cmds=$module_expsym_cmds + else + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + cmds=$archive_expsym_cmds + else + cmds=$archive_cmds + fi + fi + + # Append the command to remove the reloadable object files + # to the just-reset $cmds. + eval cmds=\"\$cmds~\$rm $delfiles\" + fi + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + + # Restore the uninstalled library and exit + if test "$mode" = relink; then + $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $? + exit $EXIT_SUCCESS + fi + + # Create links to the real library. + for linkname in $linknames; do + if test "$realname" != "$linkname"; then + $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)" + $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $? + fi + done + + # If -module or -export-dynamic was specified, set the dlname. + if test "$module" = yes || test "$export_dynamic" = yes; then + # On all known operating systems, these are identical. + dlname="$soname" + fi + fi + ;; + + obj) + if test -n "$deplibs"; then + $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 + fi + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2 + fi + + if test -n "$rpath"; then + $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2 + fi + + if test -n "$xrpath"; then + $echo "$modename: warning: \`-R' is ignored for objects" 1>&2 + fi + + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for objects" 1>&2 + fi + + case $output in + *.lo) + if test -n "$objs$old_deplibs"; then + $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2 + exit $EXIT_FAILURE + fi + libobj="$output" + obj=`$echo "X$output" | $Xsed -e "$lo2o"` + ;; + *) + libobj= + obj="$output" + ;; + esac + + # Delete the old objects. + $run $rm $obj $libobj + + # Objects from convenience libraries. This assumes + # single-version convenience libraries. Whenever we create + # different ones for PIC/non-PIC, this we'll have to duplicate + # the extraction. + reload_conv_objs= + gentop= + # reload_cmds runs $LD directly, so let us get rid of + # -Wl from whole_archive_flag_spec + wl= + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\" + else + gentop="$output_objdir/${obj}x" + $show "${rm}r $gentop" + $run ${rm}r "$gentop" + $show "$mkdir $gentop" + $run $mkdir "$gentop" + status=$? + if test "$status" -ne 0 && test ! -d "$gentop"; then + exit $status + fi + generated="$generated $gentop" + + for xlib in $convenience; do + # Extract the objects. + case $xlib in + [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;; + *) xabs=`pwd`"/$xlib" ;; + esac + xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'` + xdir="$gentop/$xlib" + + $show "${rm}r $xdir" + $run ${rm}r "$xdir" + $show "$mkdir $xdir" + $run $mkdir "$xdir" + status=$? + if test "$status" -ne 0 && test ! -d "$xdir"; then + exit $status + fi + # We will extract separately just the conflicting names and we will no + # longer touch any unique names. It is faster to leave these extract + # automatically by $AR in one run. + $show "(cd $xdir && $AR x $xabs)" + $run eval "(cd \$xdir && $AR x \$xabs)" || exit $? + if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; renaming object files" 1>&2 + $echo "$modename: warning: to ensure that they will not overwrite" 1>&2 + $AR t "$xabs" | sort | uniq -cd | while read -r count name + do + i=1 + while test "$i" -le "$count" + do + # Put our $i before any first dot (extension) + # Never overwrite any file + name_to="$name" + while test "X$name_to" = "X$name" || test -f "$xdir/$name_to" + do + name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"` + done + $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')" + $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $? + i=`expr $i + 1` + done + done + fi + + reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP` + done + fi + fi + + # Create the old-style object. + reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test + + output="$obj" + cmds=$reload_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + + # Exit if we aren't doing a library object file. + if test -z "$libobj"; then + if test -n "$gentop"; then + $show "${rm}r $gentop" + $run ${rm}r $gentop + fi + + exit $EXIT_SUCCESS + fi + + if test "$build_libtool_libs" != yes; then + if test -n "$gentop"; then + $show "${rm}r $gentop" + $run ${rm}r $gentop + fi + + # Create an invalid libtool object if no PIC, so that we don't + # accidentally link it into a program. + # $show "echo timestamp > $libobj" + # $run eval "echo timestamp > $libobj" || exit $? + exit $EXIT_SUCCESS + fi + + if test -n "$pic_flag" || test "$pic_mode" != default; then + # Only do commands if we really have different PIC objects. + reload_objs="$libobjs $reload_conv_objs" + output="$libobj" + cmds=$reload_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + + if test -n "$gentop"; then + $show "${rm}r $gentop" + $run ${rm}r $gentop + fi + + exit $EXIT_SUCCESS + ;; + + prog) + case $host in + *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;; + esac + if test -n "$vinfo"; then + $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2 + fi + + if test -n "$release"; then + $echo "$modename: warning: \`-release' is ignored for programs" 1>&2 + fi + + if test "$preload" = yes; then + if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown && + test "$dlopen_self_static" = unknown; then + $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support." + fi + fi + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'` + finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'` + ;; + esac + + case $host in + *darwin*) + # Don't allow lazy linking, it breaks C++ global constructors + if test "$tagname" = CXX ; then + compile_command="$compile_command ${wl}-bind_at_load" + finalize_command="$finalize_command ${wl}-bind_at_load" + fi + ;; + esac + + compile_command="$compile_command $compile_deplibs" + finalize_command="$finalize_command $finalize_deplibs" + + if test -n "$rpath$xrpath"; then + # If the user specified any rpath flags, then add them. + for libdir in $rpath $xrpath; do + # This is the magic to use -rpath. + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath="$finalize_rpath $libdir" ;; + esac + done + fi + + # Now hardcode the library paths + rpath= + hardcode_libdirs= + for libdir in $compile_rpath $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + rpath="$rpath $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) perm_rpath="$perm_rpath $libdir" ;; + esac + fi + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*) + case :$dllsearchpath: in + *":$libdir:"*) ;; + *) dllsearchpath="$dllsearchpath:$libdir";; + esac + ;; + esac + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + compile_rpath="$rpath" + + rpath= + hardcode_libdirs= + for libdir in $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + rpath="$rpath $flag" + fi + elif test -n "$runpath_var"; then + case "$finalize_perm_rpath " in + *" $libdir "*) ;; + *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + finalize_rpath="$rpath" + + if test -n "$libobjs" && test "$build_old_libs" = yes; then + # Transform all the library objects into standard objects. + compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + fi + + dlsyms= + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + if test -n "$NM" && test -n "$global_symbol_pipe"; then + dlsyms="${outputname}S.c" + else + $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2 + fi + fi + + if test -n "$dlsyms"; then + case $dlsyms in + "") ;; + *.c) + # Discover the nlist of each of the dlfiles. + nlist="$output_objdir/${outputname}.nm" + + $show "$rm $nlist ${nlist}S ${nlist}T" + $run $rm "$nlist" "${nlist}S" "${nlist}T" + + # Parse the name list into a source file. + $show "creating $output_objdir/$dlsyms" + + test -z "$run" && $echo > "$output_objdir/$dlsyms" "\ +/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */ +/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */ + +#ifdef __cplusplus +extern \"C\" { +#endif + +/* Prevent the only kind of declaration conflicts we can make. */ +#define lt_preloaded_symbols some_other_symbol + +/* External symbol declarations for the compiler. */\ +" + + if test "$dlself" = yes; then + $show "generating symbol list for \`$output'" + + test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist" + + # Add our own program objects to the symbol list. + progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP` + for arg in $progfiles; do + $show "extracting global C symbols from \`$arg'" + $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'" + done + + if test -n "$exclude_expsyms"; then + $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' + $run eval '$mv "$nlist"T "$nlist"' + fi + + if test -n "$export_symbols_regex"; then + $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' + $run eval '$mv "$nlist"T "$nlist"' + fi + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + export_symbols="$output_objdir/$output.exp" + $run $rm $export_symbols + $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' + else + $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"' + $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T' + $run eval 'mv "$nlist"T "$nlist"' + fi + fi + + for arg in $dlprefiles; do + $show "extracting global C symbols from \`$arg'" + name=`$echo "$arg" | ${SED} -e 's%^.*/%%'` + $run eval '$echo ": $name " >> "$nlist"' + $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'" + done + + if test -z "$run"; then + # Make sure we have at least an empty file. + test -f "$nlist" || : > "$nlist" + + if test -n "$exclude_expsyms"; then + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T + $mv "$nlist"T "$nlist" + fi + + # Try sorting and uniquifying the output. + if grep -v "^: " < "$nlist" | + if sort -k 3 /dev/null 2>&1; then + sort -k 3 + else + sort +2 + fi | + uniq > "$nlist"S; then + : + else + grep -v "^: " < "$nlist" > "$nlist"S + fi + + if test -f "$nlist"S; then + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"' + else + $echo '/* NONE */' >> "$output_objdir/$dlsyms" + fi + + $echo >> "$output_objdir/$dlsyms" "\ + +#undef lt_preloaded_symbols + +#if defined (__STDC__) && __STDC__ +# define lt_ptr void * +#else +# define lt_ptr char * +# define const +#endif + +/* The mapping between symbol names and symbols. */ +const struct { + const char *name; + lt_ptr address; +} +lt_preloaded_symbols[] = +{\ +" + + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms" + + $echo >> "$output_objdir/$dlsyms" "\ + {0, (lt_ptr) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif\ +" + fi + + pic_flag_for_symtable= + case $host in + # compiling the symbol table file with pic_flag works around + # a FreeBSD bug that causes programs to crash when -lm is + # linked before any other PIC object. But we must not use + # pic_flag when linking with -static. The problem exists in + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. + *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) + case "$compile_command " in + *" -static "*) ;; + *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";; + esac;; + *-*-hpux*) + case "$compile_command " in + *" -static "*) ;; + *) pic_flag_for_symtable=" $pic_flag";; + esac + esac + + # Now compile the dynamic symbol file. + $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")" + $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $? + + # Clean up the generated files. + $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T" + $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T" + + # Transform the symbol file into the correct name. + compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"` + finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"` + ;; + *) + $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2 + exit $EXIT_FAILURE + ;; + esac + else + # We keep going just in case the user didn't refer to + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe + # really was required. + + # Nullify the symbol file. + compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"` + finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"` + fi + + if test "$need_relink" = no || test "$build_libtool_libs" != yes; then + # Replace the output file specification. + compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` + link_command="$compile_command$compile_rpath" + + # We have no uninstalled library dependencies, so finalize right now. + $show "$link_command" + $run eval "$link_command" + status=$? + + # Delete the generated files. + if test -n "$dlsyms"; then + $show "$rm $output_objdir/${outputname}S.${objext}" + $run $rm "$output_objdir/${outputname}S.${objext}" + fi + + exit $status + fi + + if test -n "$shlibpath_var"; then + # We should set the shlibpath_var + rpath= + for dir in $temp_rpath; do + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) + # Absolute path. + rpath="$rpath$dir:" + ;; + *) + # Relative path: add a thisdir entry. + rpath="$rpath\$thisdir/$dir:" + ;; + esac + done + temp_rpath="$rpath" + fi + + if test -n "$compile_shlibpath$finalize_shlibpath"; then + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" + fi + if test -n "$finalize_shlibpath"; then + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" + fi + + compile_var= + finalize_var= + if test -n "$runpath_var"; then + if test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + rpath="$rpath$dir:" + done + compile_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + if test -n "$finalize_perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $finalize_perm_rpath; do + rpath="$rpath$dir:" + done + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + fi + + if test "$no_install" = yes; then + # We don't need to create a wrapper script. + link_command="$compile_var$compile_command$compile_rpath" + # Replace the output file specification. + link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` + # Delete the old output file. + $run $rm $output + # Link the executable and exit + $show "$link_command" + $run eval "$link_command" || exit $? + exit $EXIT_SUCCESS + fi + + if test "$hardcode_action" = relink; then + # Fast installation is not supported + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + + $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2 + $echo "$modename: \`$output' will be relinked during installation" 1>&2 + else + if test "$fast_install" != no; then + link_command="$finalize_var$compile_command$finalize_rpath" + if test "$fast_install" = yes; then + relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'` + else + # fast_install is set to needless + relink_command= + fi + else + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + fi + fi + + # Replace the output file specification. + link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` + + # Delete the old output files. + $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname + + $show "$link_command" + $run eval "$link_command" || exit $? + + # Now create the wrapper script. + $show "creating $output" + + # Quote the relink command for shipping. + if test -n "$relink_command"; then + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"` + relink_command="$var=\"$var_value\"; export $var; $relink_command" + fi + done + relink_command="(cd `pwd`; $relink_command)" + relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"` + fi + + # Quote $echo for shipping. + if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then + case $progpath in + [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";; + *) qecho="$SHELL `pwd`/$progpath --fallback-echo";; + esac + qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"` + else + qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"` + fi + + # Only actually do things if our run command is non-null. + if test -z "$run"; then + # win32 will think the script is a binary if it has + # a .exe suffix, so we strip it off here. + case $output in + *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;; + esac + # test for cygwin because mv fails w/o .exe extensions + case $host in + *cygwin*) + exeext=.exe + outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;; + *) exeext= ;; + esac + case $host in + *cygwin* | *mingw* ) + cwrappersource=`$echo ${objdir}/lt-${output}.c` + cwrapper=`$echo ${output}.exe` + $rm $cwrappersource $cwrapper + trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 + + cat > $cwrappersource <> $cwrappersource<<"EOF" +#include +#include +#include +#include +#include +#include + +#if defined(PATH_MAX) +# define LT_PATHMAX PATH_MAX +#elif defined(MAXPATHLEN) +# define LT_PATHMAX MAXPATHLEN +#else +# define LT_PATHMAX 1024 +#endif + +#ifndef DIR_SEPARATOR +#define DIR_SEPARATOR '/' +#endif + +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ + defined (__OS2__) +#define HAVE_DOS_BASED_FILE_SYSTEM +#ifndef DIR_SEPARATOR_2 +#define DIR_SEPARATOR_2 '\\' +#endif +#endif + +#ifndef DIR_SEPARATOR_2 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) +#else /* DIR_SEPARATOR_2 */ +# define IS_DIR_SEPARATOR(ch) \ + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) +#endif /* DIR_SEPARATOR_2 */ + +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) +#define XFREE(stale) do { \ + if (stale) { free ((void *) stale); stale = 0; } \ +} while (0) + +const char *program_name = NULL; + +void * xmalloc (size_t num); +char * xstrdup (const char *string); +char * basename (const char *name); +char * fnqualify(const char *path); +char * strendzap(char *str, const char *pat); +void lt_fatal (const char *message, ...); + +int +main (int argc, char *argv[]) +{ + char **newargz; + int i; + + program_name = (char *) xstrdup ((char *) basename (argv[0])); + newargz = XMALLOC(char *, argc+2); +EOF + + cat >> $cwrappersource <> $cwrappersource <<"EOF" + newargz[1] = fnqualify(argv[0]); + /* we know the script has the same name, without the .exe */ + /* so make sure newargz[1] doesn't end in .exe */ + strendzap(newargz[1],".exe"); + for (i = 1; i < argc; i++) + newargz[i+1] = xstrdup(argv[i]); + newargz[argc+1] = NULL; +EOF + + cat >> $cwrappersource <> $cwrappersource <<"EOF" +} + +void * +xmalloc (size_t num) +{ + void * p = (void *) malloc (num); + if (!p) + lt_fatal ("Memory exhausted"); + + return p; +} + +char * +xstrdup (const char *string) +{ + return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL +; +} + +char * +basename (const char *name) +{ + const char *base; + +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + /* Skip over the disk name in MSDOS pathnames. */ + if (isalpha (name[0]) && name[1] == ':') + name += 2; +#endif + + for (base = name; *name; name++) + if (IS_DIR_SEPARATOR (*name)) + base = name + 1; + return (char *) base; +} + +char * +fnqualify(const char *path) +{ + size_t size; + char *p; + char tmp[LT_PATHMAX + 1]; + + assert(path != NULL); + + /* Is it qualified already? */ +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + if (isalpha (path[0]) && path[1] == ':') + return xstrdup (path); +#endif + if (IS_DIR_SEPARATOR (path[0])) + return xstrdup (path); + + /* prepend the current directory */ + /* doesn't handle '~' */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal ("getcwd failed"); + size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */ + p = XMALLOC(char, size); + sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path); + return p; +} + +char * +strendzap(char *str, const char *pat) +{ + size_t len, patlen; + + assert(str != NULL); + assert(pat != NULL); + + len = strlen(str); + patlen = strlen(pat); + + if (patlen <= len) + { + str += len - patlen; + if (strcmp(str, pat) == 0) + *str = '\0'; + } + return str; +} + +static void +lt_error_core (int exit_status, const char * mode, + const char * message, va_list ap) +{ + fprintf (stderr, "%s: %s: ", program_name, mode); + vfprintf (stderr, message, ap); + fprintf (stderr, ".\n"); + + if (exit_status >= 0) + exit (exit_status); +} + +void +lt_fatal (const char *message, ...) +{ + va_list ap; + va_start (ap, message); + lt_error_core (EXIT_FAILURE, "FATAL", message, ap); + va_end (ap); +} +EOF + # we should really use a build-platform specific compiler + # here, but OTOH, the wrappers (shell script and this C one) + # are only useful if you want to execute the "real" binary. + # Since the "real" binary is built for $host, then this + # wrapper might as well be built for $host, too. + $run $LTCC -s -o $cwrapper $cwrappersource + ;; + esac + $rm $output + trap "$rm $output; exit $EXIT_FAILURE" 1 2 15 + + $echo > $output "\ +#! $SHELL + +# $output - temporary wrapper script for $objdir/$outputname +# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP +# +# The $output program cannot be directly executed until all the libtool +# libraries that it depends on are installed. +# +# This wrapper script should never be moved out of the build directory. +# If it is, it will not operate correctly. + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed='${SED} -e 1s/^X//' +sed_quote_subst='$sed_quote_subst' + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi + +relink_command=\"$relink_command\" + +# This environment variable determines our operation mode. +if test \"\$libtool_install_magic\" = \"$magic\"; then + # install mode needs the following variable: + notinst_deplibs='$notinst_deplibs' +else + # When we are sourced in execute mode, \$file and \$echo are already set. + if test \"\$libtool_execute_magic\" != \"$magic\"; then + echo=\"$qecho\" + file=\"\$0\" + # Make sure echo works. + if test \"X\$1\" = X--no-reexec; then + # Discard the --no-reexec flag, and continue. + shift + elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then + # Yippee, \$echo works! + : + else + # Restart under the correct shell, and then maybe \$echo will work. + exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"} + fi + fi\ +" + $echo >> $output "\ + + # Find the directory that this script lives in. + thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\` + test \"x\$thisdir\" = \"x\$file\" && thisdir=. + + # Follow symbolic links until we get to the real thisdir. + file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\` + while test -n \"\$file\"; do + destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\` + + # If there was a directory component, then change thisdir. + if test \"x\$destdir\" != \"x\$file\"; then + case \"\$destdir\" in + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; + *) thisdir=\"\$thisdir/\$destdir\" ;; + esac + fi + + file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\` + file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\` + done + + # Try to get the absolute directory name. + absdir=\`cd \"\$thisdir\" && pwd\` + test -n \"\$absdir\" && thisdir=\"\$absdir\" +" + + if test "$fast_install" = yes; then + $echo >> $output "\ + program=lt-'$outputname'$exeext + progdir=\"\$thisdir/$objdir\" + + if test ! -f \"\$progdir/\$program\" || \\ + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ + test \"X\$file\" != \"X\$progdir/\$program\"; }; then + + file=\"\$\$-\$program\" + + if test ! -d \"\$progdir\"; then + $mkdir \"\$progdir\" + else + $rm \"\$progdir/\$file\" + fi" + + $echo >> $output "\ + + # relink executable if necessary + if test -n \"\$relink_command\"; then + if relink_command_output=\`eval \$relink_command 2>&1\`; then : + else + $echo \"\$relink_command_output\" >&2 + $rm \"\$progdir/\$file\" + exit $EXIT_FAILURE + fi + fi + + $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || + { $rm \"\$progdir/\$program\"; + $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; } + $rm \"\$progdir/\$file\" + fi" + else + $echo >> $output "\ + program='$outputname' + progdir=\"\$thisdir/$objdir\" +" + fi + + $echo >> $output "\ + + if test -f \"\$progdir/\$program\"; then" + + # Export our shlibpath_var if we have one. + if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then + $echo >> $output "\ + # Add our own library path to $shlibpath_var + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" + + # Some systems cannot cope with colon-terminated $shlibpath_var + # The second colon is a workaround for a bug in BeOS R4 sed + $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\` + + export $shlibpath_var +" + fi + + # fixup the dll searchpath if we need to. + if test -n "$dllsearchpath"; then + $echo >> $output "\ + # Add the dll search path components to the executable PATH + PATH=$dllsearchpath:\$PATH +" + fi + + $echo >> $output "\ + if test \"\$libtool_execute_magic\" != \"$magic\"; then + # Run the actual program with our arguments. +" + case $host in + # Backslashes separate directories on plain windows + *-*-mingw | *-*-os2*) + $echo >> $output "\ + exec \$progdir\\\\\$program \${1+\"\$@\"} +" + ;; + + *) + $echo >> $output "\ + exec \$progdir/\$program \${1+\"\$@\"} +" + ;; + esac + $echo >> $output "\ + \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\" + exit $EXIT_FAILURE + fi + else + # The program doesn't exist. + \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2 + \$echo \"This script is just a wrapper for \$program.\" 1>&2 + $echo \"See the $PACKAGE documentation for more information.\" 1>&2 + exit $EXIT_FAILURE + fi +fi\ +" + chmod +x $output + fi + exit $EXIT_SUCCESS + ;; + esac + + # See if we need to build an old-fashioned archive. + for oldlib in $oldlibs; do + + if test "$build_libtool_libs" = convenience; then + oldobjs="$libobjs_save" + addlibs="$convenience" + build_libtool_libs=no + else + if test "$build_libtool_libs" = module; then + oldobjs="$libobjs_save" + build_libtool_libs=no + else + oldobjs="$old_deplibs $non_pic_objects" + fi + addlibs="$old_convenience" + fi + + if test -n "$addlibs"; then + gentop="$output_objdir/${outputname}x" + $show "${rm}r $gentop" + $run ${rm}r "$gentop" + $show "$mkdir $gentop" + $run $mkdir "$gentop" + status=$? + if test "$status" -ne 0 && test ! -d "$gentop"; then + exit $status + fi + generated="$generated $gentop" + + # Add in members from convenience archives. + for xlib in $addlibs; do + # Extract the objects. + case $xlib in + [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;; + *) xabs=`pwd`"/$xlib" ;; + esac + xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'` + xdir="$gentop/$xlib" + + $show "${rm}r $xdir" + $run ${rm}r "$xdir" + $show "$mkdir $xdir" + $run $mkdir "$xdir" + status=$? + if test "$status" -ne 0 && test ! -d "$xdir"; then + exit $status + fi + # We will extract separately just the conflicting names and we will no + # longer touch any unique names. It is faster to leave these extract + # automatically by $AR in one run. + $show "(cd $xdir && $AR x $xabs)" + $run eval "(cd \$xdir && $AR x \$xabs)" || exit $? + if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; renaming object files" 1>&2 + $echo "$modename: warning: to ensure that they will not overwrite" 1>&2 + $AR t "$xabs" | sort | uniq -cd | while read -r count name + do + i=1 + while test "$i" -le "$count" + do + # Put our $i before any first dot (extension) + # Never overwrite any file + name_to="$name" + while test "X$name_to" = "X$name" || test -f "$xdir/$name_to" + do + name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"` + done + $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')" + $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $? + i=`expr $i + 1` + done + done + fi + + oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP` + done + fi + + # Do each command in the archive commands. + if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then + cmds=$old_archive_from_new_cmds + else + eval cmds=\"$old_archive_cmds\" + + if len=`expr "X$cmds" : ".*"` && + test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then + cmds=$old_archive_cmds + else + # the command line is too long to link in one step, link in parts + $echo "using piecewise archive linking..." + save_RANLIB=$RANLIB + RANLIB=: + objlist= + concat_cmds= + save_oldobjs=$oldobjs + # GNU ar 2.10+ was changed to match POSIX; thus no paths are + # encoded into archives. This makes 'ar r' malfunction in + # this piecewise linking case whenever conflicting object + # names appear in distinct ar calls; check, warn and compensate. + if (for obj in $save_oldobjs + do + $echo "X$obj" | $Xsed -e 's%^.*/%%' + done | sort | sort -uc >/dev/null 2>&1); then + : + else + $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2 + $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2 + AR_FLAGS=cq + fi + # Is there a better way of finding the last object in the list? + for obj in $save_oldobjs + do + last_oldobj=$obj + done + for obj in $save_oldobjs + do + oldobjs="$objlist $obj" + objlist="$objlist $obj" + eval test_cmds=\"$old_archive_cmds\" + if len=`expr "X$test_cmds" : ".*"` && + test "$len" -le "$max_cmd_len"; then + : + else + # the above command should be used before it gets too long + oldobjs=$objlist + if test "$obj" = "$last_oldobj" ; then + RANLIB=$save_RANLIB + fi + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" + objlist= + fi + done + RANLIB=$save_RANLIB + oldobjs=$objlist + if test "X$oldobjs" = "X" ; then + eval cmds=\"\$concat_cmds\" + else + eval cmds=\"\$concat_cmds~\$old_archive_cmds\" + fi + fi + fi + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + eval cmd=\"$cmd\" + IFS="$save_ifs" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + done + + if test -n "$generated"; then + $show "${rm}r$generated" + $run ${rm}r$generated + fi + + # Now create the libtool archive. + case $output in + *.la) + old_library= + test "$build_old_libs" = yes && old_library="$libname.$libext" + $show "creating $output" + + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"` + relink_command="$var=\"$var_value\"; export $var; $relink_command" + fi + done + # Quote the link command for shipping. + relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" + relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"` + if test "$hardcode_automatic" = yes ; then + relink_command= + fi + + + # Only create the output if not a dry run. + if test -z "$run"; then + for installed in no yes; do + if test "$installed" = yes; then + if test -z "$install_libdir"; then + break + fi + output="$output_objdir/$outputname"i + # Replace all uninstalled libtool libraries with the installed ones + newdependency_libs= + for deplib in $dependency_libs; do + case $deplib in + *.la) + name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'` + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + if test -z "$libdir"; then + $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + newdependency_libs="$newdependency_libs $libdir/$name" + ;; + *) newdependency_libs="$newdependency_libs $deplib" ;; + esac + done + dependency_libs="$newdependency_libs" + newdlfiles= + for lib in $dlfiles; do + name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'` + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + if test -z "$libdir"; then + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + newdlfiles="$newdlfiles $libdir/$name" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'` + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + if test -z "$libdir"; then + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + exit $EXIT_FAILURE + fi + newdlprefiles="$newdlprefiles $libdir/$name" + done + dlprefiles="$newdlprefiles" + else + newdlfiles= + for lib in $dlfiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + newdlfiles="$newdlfiles $abs" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + newdlprefiles="$newdlprefiles $abs" + done + dlprefiles="$newdlprefiles" + fi + $rm $output + # place dlname in correct position for cygwin + tdlname=$dlname + case $host,$output,$installed,$module,$dlname in + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;; + esac + $echo > $output "\ +# $outputname - a libtool library file +# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='$tdlname' + +# Names of this library. +library_names='$library_names' + +# The name of the static archive. +old_library='$old_library' + +# Libraries that this one depends upon. +dependency_libs='$dependency_libs' + +# Version information for $libname. +current=$current +age=$age +revision=$revision + +# Is this an already installed library? +installed=$installed + +# Should we warn about portability when linking against -modules? +shouldnotlink=$module + +# Files to dlopen/dlpreopen +dlopen='$dlfiles' +dlpreopen='$dlprefiles' + +# Directory that this library needs to be installed in: +libdir='$install_libdir'" + if test "$installed" = no && test "$need_relink" = yes; then + $echo >> $output "\ +relink_command=\"$relink_command\"" + fi + done + fi + + # Do a symbolic link so that the libtool archive can be found in + # LD_LIBRARY_PATH before the program is installed. + $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)" + $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $? + ;; + esac + exit $EXIT_SUCCESS + ;; + + # libtool install mode + install) + modename="$modename: install" + + # There may be an optional sh(1) argument at the beginning of + # install_prog (especially on Windows NT). + if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || + # Allow the use of GNU shtool's install command. + $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then + # Aesthetically quote it. + arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) + arg="\"$arg\"" + ;; + esac + install_prog="$arg " + arg="$1" + shift + else + install_prog= + arg="$nonopt" + fi + + # The real first argument should be the name of the installation program. + # Aesthetically quote it. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) + arg="\"$arg\"" + ;; + esac + install_prog="$install_prog$arg" + + # We need to accept at least all the BSD install flags. + dest= + files= + opts= + prev= + install_type= + isdir=no + stripme= + for arg + do + if test -n "$dest"; then + files="$files $dest" + dest="$arg" + continue + fi + + case $arg in + -d) isdir=yes ;; + -f) prev="-f" ;; + -g) prev="-g" ;; + -m) prev="-m" ;; + -o) prev="-o" ;; + -s) + stripme=" -s" + continue + ;; + -*) ;; + + *) + # If the previous option needed an argument, then skip it. + if test -n "$prev"; then + prev= + else + dest="$arg" + continue + fi + ;; + esac + + # Aesthetically quote the argument. + arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` + case $arg in + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) + arg="\"$arg\"" + ;; + esac + install_prog="$install_prog $arg" + done + + if test -z "$install_prog"; then + $echo "$modename: you must specify an install program" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + if test -n "$prev"; then + $echo "$modename: the \`$prev' option requires an argument" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + if test -z "$files"; then + if test -z "$dest"; then + $echo "$modename: no file or destination specified" 1>&2 + else + $echo "$modename: you must specify a destination" 1>&2 + fi + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Strip any trailing slash from the destination. + dest=`$echo "X$dest" | $Xsed -e 's%/$%%'` + + # Check to see that the destination is a directory. + test -d "$dest" && isdir=yes + if test "$isdir" = yes; then + destdir="$dest" + destname= + else + destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'` + test "X$destdir" = "X$dest" && destdir=. + destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'` + + # Not a directory, so check to see that there is only one file specified. + set dummy $files + if test "$#" -gt 2; then + $echo "$modename: \`$dest' is not a directory" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + fi + case $destdir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + for file in $files; do + case $file in + *.lo) ;; + *) + $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + esac + done + ;; + esac + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + staticlibs= + future_libdirs= + current_libdirs= + for file in $files; do + + # Do each installation. + case $file in + *.$libext) + # Do the static libraries later. + staticlibs="$staticlibs $file" + ;; + + *.la) + # Check to see that this really is a libtool archive. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then : + else + $echo "$modename: \`$file' is not a valid libtool archive" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + library_names= + old_library= + relink_command= + # If there is no directory component, then add one. + case $file in + */* | *\\*) . $file ;; + *) . ./$file ;; + esac + + # Add the libdir to current_libdirs if it is the destination. + if test "X$destdir" = "X$libdir"; then + case "$current_libdirs " in + *" $libdir "*) ;; + *) current_libdirs="$current_libdirs $libdir" ;; + esac + else + # Note the libdir as a future libdir. + case "$future_libdirs " in + *" $libdir "*) ;; + *) future_libdirs="$future_libdirs $libdir" ;; + esac + fi + + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/ + test "X$dir" = "X$file/" && dir= + dir="$dir$objdir" + + if test -n "$relink_command"; then + # Determine the prefix the user has applied to our future dir. + inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"` + + # Don't allow the user to place us outside of our expected + # location b/c this prevents finding dependent libraries that + # are installed to the same prefix. + # At present, this check doesn't affect windows .dll's that + # are installed into $libdir/../bin (currently, that works fine) + # but it's something to keep an eye on. + if test "$inst_prefix_dir" = "$destdir"; then + $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2 + exit $EXIT_FAILURE + fi + + if test -n "$inst_prefix_dir"; then + # Stick the inst_prefix_dir data into the link command. + relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` + else + relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"` + fi + + $echo "$modename: warning: relinking \`$file'" 1>&2 + $show "$relink_command" + if $run eval "$relink_command"; then : + else + $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2 + exit $EXIT_FAILURE + fi + fi + + # See the names of the shared library. + set dummy $library_names + if test -n "$2"; then + realname="$2" + shift + shift + + srcname="$realname" + test -n "$relink_command" && srcname="$realname"T + + # Install the shared library and build the symlinks. + $show "$install_prog $dir/$srcname $destdir/$realname" + $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $? + if test -n "$stripme" && test -n "$striplib"; then + $show "$striplib $destdir/$realname" + $run eval "$striplib $destdir/$realname" || exit $? + fi + + if test "$#" -gt 0; then + # Delete the old symlinks, and create new ones. + for linkname + do + if test "$linkname" != "$realname"; then + $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)" + $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)" + fi + done + fi + + # Do each command in the postinstall commands. + lib="$destdir/$realname" + cmds=$postinstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + fi + + # Install the pseudo-library for information purposes. + name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + instname="$dir/$name"i + $show "$install_prog $instname $destdir/$name" + $run eval "$install_prog $instname $destdir/$name" || exit $? + + # Maybe install the static library, too. + test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library" + ;; + + *.lo) + # Install (i.e. copy) a libtool object. + + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + destfile="$destdir/$destfile" + fi + + # Deduce the name of the destination old-style object file. + case $destfile in + *.lo) + staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"` + ;; + *.$objext) + staticdest="$destfile" + destfile= + ;; + *) + $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + # Install the libtool object if requested. + if test -n "$destfile"; then + $show "$install_prog $file $destfile" + $run eval "$install_prog $file $destfile" || exit $? + fi + + # Install the old object if enabled. + if test "$build_old_libs" = yes; then + # Deduce the name of the old-style object file. + staticobj=`$echo "X$file" | $Xsed -e "$lo2o"` + + $show "$install_prog $staticobj $staticdest" + $run eval "$install_prog \$staticobj \$staticdest" || exit $? + fi + exit $EXIT_SUCCESS + ;; + + *) + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + destfile="$destdir/$destfile" + fi + + # If the file is missing, and there is a .exe on the end, strip it + # because it is most likely a libtool script we actually want to + # install + stripped_ext="" + case $file in + *.exe) + if test ! -f "$file"; then + file=`$echo $file|${SED} 's,.exe$,,'` + stripped_ext=".exe" + fi + ;; + esac + + # Do a test to see if this is really a libtool program. + case $host in + *cygwin*|*mingw*) + wrapper=`$echo $file | ${SED} -e 's,.exe$,,'` + ;; + *) + wrapper=$file + ;; + esac + if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then + notinst_deplibs= + relink_command= + + # To insure that "foo" is sourced, and not "foo.exe", + # finese the cygwin/MSYS system by explicitly sourcing "foo." + # which disallows the automatic-append-.exe behavior. + case $build in + *cygwin* | *mingw*) wrapperdot=${wrapper}. ;; + *) wrapperdot=${wrapper} ;; + esac + # If there is no directory component, then add one. + case $file in + */* | *\\*) . ${wrapperdot} ;; + *) . ./${wrapperdot} ;; + esac + + # Check the variables that should have been set. + if test -z "$notinst_deplibs"; then + $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2 + exit $EXIT_FAILURE + fi + + finalize=yes + for lib in $notinst_deplibs; do + # Check to see that each library is installed. + libdir= + if test -f "$lib"; then + # If there is no directory component, then add one. + case $lib in + */* | *\\*) . $lib ;; + *) . ./$lib ;; + esac + fi + libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test + if test -n "$libdir" && test ! -f "$libfile"; then + $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2 + finalize=no + fi + done + + relink_command= + # To insure that "foo" is sourced, and not "foo.exe", + # finese the cygwin/MSYS system by explicitly sourcing "foo." + # which disallows the automatic-append-.exe behavior. + case $build in + *cygwin* | *mingw*) wrapperdot=${wrapper}. ;; + *) wrapperdot=${wrapper} ;; + esac + # If there is no directory component, then add one. + case $file in + */* | *\\*) . ${wrapperdot} ;; + *) . ./${wrapperdot} ;; + esac + + outputname= + if test "$fast_install" = no && test -n "$relink_command"; then + if test "$finalize" = yes && test -z "$run"; then + tmpdir="/tmp" + test -n "$TMPDIR" && tmpdir="$TMPDIR" + tmpdir="$tmpdir/libtool-$$" + save_umask=`umask` + umask 0077 + if $mkdir "$tmpdir"; then + umask $save_umask + else + umask $save_umask + $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2 + continue + fi + file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'` + outputname="$tmpdir/$file" + # Replace the output file specification. + relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'` + + $show "$relink_command" + if $run eval "$relink_command"; then : + else + $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2 + ${rm}r "$tmpdir" + continue + fi + file="$outputname" + else + $echo "$modename: warning: cannot relink \`$file'" 1>&2 + fi + else + # Install the binary that we compiled earlier. + file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"` + fi + fi + + # remove .exe since cygwin /usr/bin/install will append another + # one anyways + case $install_prog,$host in + */usr/bin/install*,*cygwin*) + case $file:$destfile in + *.exe:*.exe) + # this is ok + ;; + *.exe:*) + destfile=$destfile.exe + ;; + *:*.exe) + destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'` + ;; + esac + ;; + esac + $show "$install_prog$stripme $file $destfile" + $run eval "$install_prog\$stripme \$file \$destfile" || exit $? + test -n "$outputname" && ${rm}r "$tmpdir" + ;; + esac + done + + for file in $staticlibs; do + name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + + # Set up the ranlib parameters. + oldlib="$destdir/$name" + + $show "$install_prog $file $oldlib" + $run eval "$install_prog \$file \$oldlib" || exit $? + + if test -n "$stripme" && test -n "$old_striplib"; then + $show "$old_striplib $oldlib" + $run eval "$old_striplib $oldlib" || exit $? + fi + + # Do each command in the postinstall commands. + cmds=$old_postinstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || exit $? + done + IFS="$save_ifs" + done + + if test -n "$future_libdirs"; then + $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2 + fi + + if test -n "$current_libdirs"; then + # Maybe just do a dry run. + test -n "$run" && current_libdirs=" -n$current_libdirs" + exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' + else + exit $EXIT_SUCCESS + fi + ;; + + # libtool finish mode + finish) + modename="$modename: finish" + libdirs="$nonopt" + admincmds= + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + for dir + do + libdirs="$libdirs $dir" + done + + for libdir in $libdirs; do + if test -n "$finish_cmds"; then + # Do each command in the finish commands. + cmds=$finish_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" || admincmds="$admincmds + $cmd" + done + IFS="$save_ifs" + fi + if test -n "$finish_eval"; then + # Do the single finish_eval. + eval cmds=\"$finish_eval\" + $run eval "$cmds" || admincmds="$admincmds + $cmds" + fi + done + fi + + # Exit here if they wanted silent mode. + test "$show" = : && exit $EXIT_SUCCESS + + $echo "----------------------------------------------------------------------" + $echo "Libraries have been installed in:" + for libdir in $libdirs; do + $echo " $libdir" + done + $echo + $echo "If you ever happen to want to link against installed libraries" + $echo "in a given directory, LIBDIR, you must either use libtool, and" + $echo "specify the full pathname of the library, or use the \`-LLIBDIR'" + $echo "flag during linking and do at least one of the following:" + if test -n "$shlibpath_var"; then + $echo " - add LIBDIR to the \`$shlibpath_var' environment variable" + $echo " during execution" + fi + if test -n "$runpath_var"; then + $echo " - add LIBDIR to the \`$runpath_var' environment variable" + $echo " during linking" + fi + if test -n "$hardcode_libdir_flag_spec"; then + libdir=LIBDIR + eval flag=\"$hardcode_libdir_flag_spec\" + + $echo " - use the \`$flag' linker flag" + fi + if test -n "$admincmds"; then + $echo " - have your system administrator run these commands:$admincmds" + fi + if test -f /etc/ld.so.conf; then + $echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" + fi + $echo + $echo "See any operating system documentation about shared libraries for" + $echo "more information, such as the ld(1) and ld.so(8) manual pages." + $echo "----------------------------------------------------------------------" + exit $EXIT_SUCCESS + ;; + + # libtool execute mode + execute) + modename="$modename: execute" + + # The first argument is the command name. + cmd="$nonopt" + if test -z "$cmd"; then + $echo "$modename: you must specify a COMMAND" 1>&2 + $echo "$help" + exit $EXIT_FAILURE + fi + + # Handle -dlopen flags immediately. + for file in $execute_dlfiles; do + if test ! -f "$file"; then + $echo "$modename: \`$file' is not a file" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + dir= + case $file in + *.la) + # Check to see that this really is a libtool archive. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then : + else + $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Read the libtool library. + dlname= + library_names= + + # If there is no directory component, then add one. + case $file in + */* | *\\*) . $file ;; + *) . ./$file ;; + esac + + # Skip this library if it cannot be dlopened. + if test -z "$dlname"; then + # Warn if it was a shared library. + test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'" + continue + fi + + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` + test "X$dir" = "X$file" && dir=. + + if test -f "$dir/$objdir/$dlname"; then + dir="$dir/$objdir" + else + $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2 + exit $EXIT_FAILURE + fi + ;; + + *.lo) + # Just add the directory containing the .lo file. + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` + test "X$dir" = "X$file" && dir=. + ;; + + *) + $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2 + continue + ;; + esac + + # Get the absolute pathname. + absdir=`cd "$dir" && pwd` + test -n "$absdir" && dir="$absdir" + + # Now add the directory to shlibpath_var. + if eval "test -z \"\$$shlibpath_var\""; then + eval "$shlibpath_var=\"\$dir\"" + else + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" + fi + done + + # This variable tells wrapper scripts just to set shlibpath_var + # rather than running their programs. + libtool_execute_magic="$magic" + + # Check if any of the arguments is a wrapper script. + args= + for file + do + case $file in + -*) ;; + *) + # Do a test to see if this is really a libtool program. + if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + # If there is no directory component, then add one. + case $file in + */* | *\\*) . $file ;; + *) . ./$file ;; + esac + + # Transform arg to wrapped name. + file="$progdir/$program" + fi + ;; + esac + # Quote arguments (to preserve shell metacharacters). + file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"` + args="$args \"$file\"" + done + + if test -z "$run"; then + if test -n "$shlibpath_var"; then + # Export the shlibpath_var. + eval "export $shlibpath_var" + fi + + # Restore saved environment variables + if test "${save_LC_ALL+set}" = set; then + LC_ALL="$save_LC_ALL"; export LC_ALL + fi + if test "${save_LANG+set}" = set; then + LANG="$save_LANG"; export LANG + fi + + # Now prepare to actually exec the command. + exec_cmd="\$cmd$args" + else + # Display what would be done. + if test -n "$shlibpath_var"; then + eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\"" + $echo "export $shlibpath_var" + fi + $echo "$cmd$args" + exit $EXIT_SUCCESS + fi + ;; + + # libtool clean and uninstall mode + clean | uninstall) + modename="$modename: $mode" + rm="$nonopt" + files= + rmforce= + exit_status=0 + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + for arg + do + case $arg in + -f) rm="$rm $arg"; rmforce=yes ;; + -*) rm="$rm $arg" ;; + *) files="$files $arg" ;; + esac + done + + if test -z "$rm"; then + $echo "$modename: you must specify an RM program" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + fi + + rmdirs= + + origobjdir="$objdir" + for file in $files; do + dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` + if test "X$dir" = "X$file"; then + dir=. + objdir="$origobjdir" + else + objdir="$dir/$origobjdir" + fi + name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` + test "$mode" = uninstall && objdir="$dir" + + # Remember objdir for removal later, being careful to avoid duplicates + if test "$mode" = clean; then + case " $rmdirs " in + *" $objdir "*) ;; + *) rmdirs="$rmdirs $objdir" ;; + esac + fi + + # Don't error if the file doesn't exist and rm -f was used. + if (test -L "$file") >/dev/null 2>&1 \ + || (test -h "$file") >/dev/null 2>&1 \ + || test -f "$file"; then + : + elif test -d "$file"; then + exit_status=1 + continue + elif test "$rmforce" = yes; then + continue + fi + + rmfiles="$file" + + case $name in + *.la) + # Possibly a libtool archive, so verify it. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + . $dir/$name + + # Delete the libtool libraries and symlinks. + for n in $library_names; do + rmfiles="$rmfiles $objdir/$n" + done + test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library" + test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i" + + if test "$mode" = uninstall; then + if test -n "$library_names"; then + # Do each command in the postuninstall commands. + cmds=$postuninstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" + if test "$?" -ne 0 && test "$rmforce" != yes; then + exit_status=1 + fi + done + IFS="$save_ifs" + fi + + if test -n "$old_library"; then + # Do each command in the old_postuninstall commands. + cmds=$old_postuninstall_cmds + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $show "$cmd" + $run eval "$cmd" + if test "$?" -ne 0 && test "$rmforce" != yes; then + exit_status=1 + fi + done + IFS="$save_ifs" + fi + # FIXME: should reinstall the best remaining shared library. + fi + fi + ;; + + *.lo) + # Possibly a libtool object, so verify it. + if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + + # Read the .lo file + . $dir/$name + + # Add PIC object to the list of files to remove. + if test -n "$pic_object" \ + && test "$pic_object" != none; then + rmfiles="$rmfiles $dir/$pic_object" + fi + + # Add non-PIC object to the list of files to remove. + if test -n "$non_pic_object" \ + && test "$non_pic_object" != none; then + rmfiles="$rmfiles $dir/$non_pic_object" + fi + fi + ;; + + *) + if test "$mode" = clean ; then + noexename=$name + case $file in + *.exe) + file=`$echo $file|${SED} 's,.exe$,,'` + noexename=`$echo $name|${SED} 's,.exe$,,'` + # $file with .exe has already been added to rmfiles, + # add $file without .exe + rmfiles="$rmfiles $file" + ;; + esac + # Do a test to see if this is a libtool program. + if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then + relink_command= + . $dir/$noexename + + # note $name still contains .exe if it was in $file originally + # as does the version of $file that was added into $rmfiles + rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}" + if test "$fast_install" = yes && test -n "$relink_command"; then + rmfiles="$rmfiles $objdir/lt-$name" + fi + if test "X$noexename" != "X$name" ; then + rmfiles="$rmfiles $objdir/lt-${noexename}.c" + fi + fi + fi + ;; + esac + $show "$rm $rmfiles" + $run $rm $rmfiles || exit_status=1 + done + objdir="$origobjdir" + + # Try to remove the ${objdir}s in the directories where we deleted files + for dir in $rmdirs; do + if test -d "$dir"; then + $show "rmdir $dir" + $run rmdir $dir >/dev/null 2>&1 + fi + done + + exit $exit_status + ;; + + "") + $echo "$modename: you must specify a MODE" 1>&2 + $echo "$generic_help" 1>&2 + exit $EXIT_FAILURE + ;; + esac + + if test -z "$exec_cmd"; then + $echo "$modename: invalid operation mode \`$mode'" 1>&2 + $echo "$generic_help" 1>&2 + exit $EXIT_FAILURE + fi +fi # test -z "$show_help" + +if test -n "$exec_cmd"; then + eval exec $exec_cmd + exit $EXIT_FAILURE +fi + +# We need to display help for each of the modes. +case $mode in +"") $echo \ +"Usage: $modename [OPTION]... [MODE-ARG]... + +Provide generalized library-building support services. + + --config show all configuration variables + --debug enable verbose shell tracing +-n, --dry-run display commands without modifying any files + --features display basic configuration information and exit + --finish same as \`--mode=finish' + --help display this help message and exit + --mode=MODE use operation mode MODE [default=inferred from MODE-ARGS] + --quiet same as \`--silent' + --silent don't print informational messages + --tag=TAG use configuration variables from tag TAG + --version print version information + +MODE must be one of the following: + + clean remove files from the build directory + compile compile a source file into a libtool object + execute automatically set library path, then run a program + finish complete the installation of libtool libraries + install install libraries or executables + link create a library or an executable + uninstall remove libraries from an installed directory + +MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for +a more detailed description of MODE. + +Report bugs to ." + exit $EXIT_SUCCESS + ;; + +clean) + $echo \ +"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE... + +Remove files from the build directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, object or program, all the files associated +with it are deleted. Otherwise, only FILE itself is deleted using RM." + ;; + +compile) + $echo \ +"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE + +Compile a source file into a libtool library object. + +This mode accepts the following additional options: + + -o OUTPUT-FILE set the output file name to OUTPUT-FILE + -prefer-pic try to building PIC objects only + -prefer-non-pic try to building non-PIC objects only + -static always build a \`.o' file suitable for static linking + +COMPILE-COMMAND is a command to be used in creating a \`standard' object file +from the given SOURCEFILE. + +The output file name is determined by removing the directory component from +SOURCEFILE, then substituting the C source code suffix \`.c' with the +library object suffix, \`.lo'." + ;; + +execute) + $echo \ +"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]... + +Automatically set library path, then run a program. + +This mode accepts the following additional options: + + -dlopen FILE add the directory containing FILE to the library path + +This mode sets the library path environment variable according to \`-dlopen' +flags. + +If any of the ARGS are libtool executable wrappers, then they are translated +into their corresponding uninstalled binary, and any of their required library +directories are added to the library path. + +Then, COMMAND is executed, with ARGS as arguments." + ;; + +finish) + $echo \ +"Usage: $modename [OPTION]... --mode=finish [LIBDIR]... + +Complete the installation of libtool libraries. + +Each LIBDIR is a directory that contains libtool libraries. + +The commands that this mode executes may require superuser privileges. Use +the \`--dry-run' option if you just want to see what would be executed." + ;; + +install) + $echo \ +"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND... + +Install executables or libraries. + +INSTALL-COMMAND is the installation command. The first component should be +either the \`install' or \`cp' program. + +The rest of the components are interpreted as arguments to that command (only +BSD-compatible install options are recognized)." + ;; + +link) + $echo \ +"Usage: $modename [OPTION]... --mode=link LINK-COMMAND... + +Link object files or libraries together to form another library, or to +create an executable program. + +LINK-COMMAND is a command using the C compiler that you would use to create +a program from several object files. + +The following components of LINK-COMMAND are treated specially: + + -all-static do not do any dynamic linking at all + -avoid-version do not add a version suffix if possible + -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) + -export-symbols SYMFILE + try to export only the symbols listed in SYMFILE + -export-symbols-regex REGEX + try to export only the symbols matching REGEX + -LLIBDIR search LIBDIR for required installed libraries + -lNAME OUTPUT-FILE requires the installed library libNAME + -module build a library that can dlopened + -no-fast-install disable the fast-install mode + -no-install link a not-installable executable + -no-undefined declare that a library does not refer to external symbols + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects + -objectlist FILE Use a list of object files found in FILE to specify objects + -precious-files-regex REGEX + don't remove output files matching REGEX + -release RELEASE specify package release information + -rpath LIBDIR the created library will eventually be installed in LIBDIR + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries + -static do not do any dynamic linking of libtool libraries + -version-info CURRENT[:REVISION[:AGE]] + specify library version info [each variable defaults to 0] + +All other options (arguments beginning with \`-') are ignored. + +Every other argument is treated as a filename. Files ending in \`.la' are +treated as uninstalled libtool libraries, other files are standard or library +object files. + +If the OUTPUT-FILE ends in \`.la', then a libtool library is created, +only library objects (\`.lo' files) may be specified, and \`-rpath' is +required, except when creating a convenience library. + +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created +using \`ar' and \`ranlib', or on Windows using \`lib'. + +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file +is created, otherwise an executable program is created." + ;; + +uninstall) + $echo \ +"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... + +Remove libraries from an installation directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, all the files associated with it are deleted. +Otherwise, only FILE itself is deleted using RM." + ;; + +*) + $echo "$modename: invalid operation mode \`$mode'" 1>&2 + $echo "$help" 1>&2 + exit $EXIT_FAILURE + ;; +esac + +$echo +$echo "Try \`$modename --help' for more information about other modes." + +exit $EXIT_SUCCESS + +# The TAGs below are defined such that we never get into a situation +# in which we disable both kinds of libraries. Given conflicting +# choices, we go for a static library, that is the most portable, +# since we can't tell whether shared libraries were disabled because +# the user asked for that or because the platform doesn't support +# them. This is particularly important on AIX, because we don't +# support having both static and shared libraries enabled at the same +# time on that platform, so we default to a shared-only configuration. +# If a disable-shared tag is given, we'll fallback to a static-only +# configuration. But we'll never go from static-only to shared-only. + +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared +build_libtool_libs=no +build_old_libs=yes +# ### END LIBTOOL TAG CONFIG: disable-shared + +# ### BEGIN LIBTOOL TAG CONFIG: disable-static +build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac` +# ### END LIBTOOL TAG CONFIG: disable-static + +# Local Variables: +# mode:shell-script +# sh-indentation:2 +# End: diff --git a/sdk/buddy-2.4/tools/missing b/sdk/buddy-2.4/tools/missing new file mode 100644 index 0000000..e7ef83a --- /dev/null +++ b/sdk/buddy-2.4/tools/missing @@ -0,0 +1,360 @@ +#! /bin/sh +# Common stub for a few missing GNU programs while installing. + +scriptversion=2003-09-02.23 + +# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003 +# Free Software Foundation, Inc. +# Originally by Fran,cois Pinard , 1996. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, 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, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +if test $# -eq 0; then + echo 1>&2 "Try \`$0 --help' for more information" + exit 1 +fi + +run=: + +# In the cases where this matters, `missing' is being run in the +# srcdir already. +if test -f configure.ac; then + configure_ac=configure.ac +else + configure_ac=configure.in +fi + +msg="missing on your system" + +case "$1" in +--run) + # Try to run requested program, and just exit if it succeeds. + run= + shift + "$@" && exit 0 + # Exit code 63 means version mismatch. This often happens + # when the user try to use an ancient version of a tool on + # a file that requires a minimum version. In this case we + # we should proceed has if the program had been absent, or + # if --run hadn't been passed. + if test $? = 63; then + run=: + msg="probably too old" + fi + ;; +esac + +# If it does not exist, or fails to run (possibly an outdated version), +# try to emulate it. +case "$1" in + + -h|--h|--he|--hel|--help) + echo "\ +$0 [OPTION]... PROGRAM [ARGUMENT]... + +Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an +error status if there is no known handling for PROGRAM. + +Options: + -h, --help display this help and exit + -v, --version output version information and exit + --run try to run the given command, and emulate it if it fails + +Supported PROGRAM values: + aclocal touch file \`aclocal.m4' + autoconf touch file \`configure' + autoheader touch file \`config.h.in' + automake touch all \`Makefile.in' files + bison create \`y.tab.[ch]', if possible, from existing .[ch] + flex create \`lex.yy.c', if possible, from existing .c + help2man touch the output file + lex create \`lex.yy.c', if possible, from existing .c + makeinfo touch the output file + tar try tar, gnutar, gtar, then tar without non-portable flags + yacc create \`y.tab.[ch]', if possible, from existing .[ch] + +Send bug reports to ." + ;; + + -v|--v|--ve|--ver|--vers|--versi|--versio|--version) + echo "missing $scriptversion (GNU Automake)" + ;; + + -*) + echo 1>&2 "$0: Unknown \`$1' option" + echo 1>&2 "Try \`$0 --help' for more information" + exit 1 + ;; + + aclocal*) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified \`acinclude.m4' or \`${configure_ac}'. You might want + to install the \`Automake' and \`Perl' packages. Grab them from + any GNU archive site." + touch aclocal.m4 + ;; + + autoconf) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified \`${configure_ac}'. You might want to install the + \`Autoconf' and \`GNU m4' packages. Grab them from any GNU + archive site." + touch configure + ;; + + autoheader) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified \`acconfig.h' or \`${configure_ac}'. You might want + to install the \`Autoconf' and \`GNU m4' packages. Grab them + from any GNU archive site." + files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}` + test -z "$files" && files="config.h" + touch_files= + for f in $files; do + case "$f" in + *:*) touch_files="$touch_files "`echo "$f" | + sed -e 's/^[^:]*://' -e 's/:.*//'`;; + *) touch_files="$touch_files $f.in";; + esac + done + touch $touch_files + ;; + + automake*) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'. + You might want to install the \`Automake' and \`Perl' packages. + Grab them from any GNU archive site." + find . -type f -name Makefile.am -print | + sed 's/\.am$/.in/' | + while read f; do touch "$f"; done + ;; + + autom4te) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is needed, but is $msg. + You might have modified some files without having the + proper tools for further handling them. + You can get \`$1' as part of \`Autoconf' from any GNU + archive site." + + file=`echo "$*" | sed -n 's/.*--output[ =]*\([^ ]*\).*/\1/p'` + test -z "$file" && file=`echo "$*" | sed -n 's/.*-o[ ]*\([^ ]*\).*/\1/p'` + if test -f "$file"; then + touch $file + else + test -z "$file" || exec >$file + echo "#! /bin/sh" + echo "# Created by GNU Automake missing as a replacement of" + echo "# $ $@" + echo "exit 0" + chmod +x $file + exit 1 + fi + ;; + + bison|yacc) + echo 1>&2 "\ +WARNING: \`$1' $msg. You should only need it if + you modified a \`.y' file. You may need the \`Bison' package + in order for those modifications to take effect. You can get + \`Bison' from any GNU archive site." + rm -f y.tab.c y.tab.h + if [ $# -ne 1 ]; then + eval LASTARG="\${$#}" + case "$LASTARG" in + *.y) + SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'` + if [ -f "$SRCFILE" ]; then + cp "$SRCFILE" y.tab.c + fi + SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'` + if [ -f "$SRCFILE" ]; then + cp "$SRCFILE" y.tab.h + fi + ;; + esac + fi + if [ ! -f y.tab.h ]; then + echo >y.tab.h + fi + if [ ! -f y.tab.c ]; then + echo 'main() { return 0; }' >y.tab.c + fi + ;; + + lex|flex) + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified a \`.l' file. You may need the \`Flex' package + in order for those modifications to take effect. You can get + \`Flex' from any GNU archive site." + rm -f lex.yy.c + if [ $# -ne 1 ]; then + eval LASTARG="\${$#}" + case "$LASTARG" in + *.l) + SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'` + if [ -f "$SRCFILE" ]; then + cp "$SRCFILE" lex.yy.c + fi + ;; + esac + fi + if [ ! -f lex.yy.c ]; then + echo 'main() { return 0; }' >lex.yy.c + fi + ;; + + help2man) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified a dependency of a manual page. You may need the + \`Help2man' package in order for those modifications to take + effect. You can get \`Help2man' from any GNU archive site." + + file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'` + if test -z "$file"; then + file=`echo "$*" | sed -n 's/.*--output=\([^ ]*\).*/\1/p'` + fi + if [ -f "$file" ]; then + touch $file + else + test -z "$file" || exec >$file + echo ".ab help2man is required to generate this page" + exit 1 + fi + ;; + + makeinfo) + if test -z "$run" && (makeinfo --version) > /dev/null 2>&1; then + # We have makeinfo, but it failed. + exit 1 + fi + + echo 1>&2 "\ +WARNING: \`$1' is $msg. You should only need it if + you modified a \`.texi' or \`.texinfo' file, or any other file + indirectly affecting the aspect of the manual. The spurious + call might also be the consequence of using a buggy \`make' (AIX, + DU, IRIX). You might want to install the \`Texinfo' package or + the \`GNU make' package. Grab either from any GNU archive site." + file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'` + if test -z "$file"; then + file=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'` + file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $file` + fi + touch $file + ;; + + tar) + shift + if test -n "$run"; then + echo 1>&2 "ERROR: \`tar' requires --run" + exit 1 + fi + + # We have already tried tar in the generic part. + # Look for gnutar/gtar before invocation to avoid ugly error + # messages. + if (gnutar --version > /dev/null 2>&1); then + gnutar "$@" && exit 0 + fi + if (gtar --version > /dev/null 2>&1); then + gtar "$@" && exit 0 + fi + firstarg="$1" + if shift; then + case "$firstarg" in + *o*) + firstarg=`echo "$firstarg" | sed s/o//` + tar "$firstarg" "$@" && exit 0 + ;; + esac + case "$firstarg" in + *h*) + firstarg=`echo "$firstarg" | sed s/h//` + tar "$firstarg" "$@" && exit 0 + ;; + esac + fi + + echo 1>&2 "\ +WARNING: I can't seem to be able to run \`tar' with the given arguments. + You may want to install GNU tar or Free paxutils, or check the + command line arguments." + exit 1 + ;; + + *) + echo 1>&2 "\ +WARNING: \`$1' is needed, and is $msg. + You might have modified some files without having the + proper tools for further handling them. Check the \`README' file, + it often tells you about the needed prerequisites for installing + this package. You may also peek at any GNU archive site, in case + some other package would contain this missing \`$1' program." + exit 1 + ;; +esac + +exit 0 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-end: "$" +# End: diff --git a/sdk/wxscintilla/CMakeLists.txt b/sdk/wxscintilla/CMakeLists.txt new file mode 100644 index 0000000..9aa8642 --- /dev/null +++ b/sdk/wxscintilla/CMakeLists.txt @@ -0,0 +1,26 @@ +# This file is part of EPOCH. +# File: CMakeLists.txt +# Author: Florent Teichteil-Königsbuch +# Contact: florent.teichteil@onera.fr +# +# EPOCH 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. +# +# EPOCH 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 EPOCH. If not, see . + +MESSAGE (STATUS "Compiling wxScintilla-1.69.2 from codelite-2.7.0.4375") +FILE (GLOB_RECURSE WXSCINTILLA_SOURCES ${CMAKE_CURRENT_SOURCE_DIR} *.cxx *.cpp) +INCLUDE_DIRECTORIES (${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/src/scintilla/include + ${CMAKE_CURRENT_SOURCE_DIR}/src/scintilla/src) +ADD_DEFINITIONS (-D__WX__=1 -DSCI_LEXER -DLINK_LEXERS) +ADD_LIBRARY (epoch-wxscintilla STATIC ${WXSCINTILLA_SOURCES}) + diff --git a/sdk/wxscintilla/include/wx/wxscintilla.h b/sdk/wxscintilla/include/wx/wxscintilla.h new file mode 100644 index 0000000..4b75cb8 --- /dev/null +++ b/sdk/wxscintilla/include/wx/wxscintilla.h @@ -0,0 +1,3837 @@ +//////////////////////////////////////////////////////////////////////////// +// Name: wxscintilla.h +// Purpose: A wxWidgets implementation of Scintilla. This class is the +// one meant to be used directly by wx applications. It does not +// derive directly from the Scintilla classes, and in fact there +// is no mention of Scintilla classes at all in this header. +// This class delegates all method calls and events to the +// Scintilla objects and so forth. This allows the use of +// Scintilla without polluting the namespace with all the +// classes and itentifiers from Scintilla. +// +// Author: Robin Dunn +// +// Created: 13-Jan-2000 +// RCS-ID: $Id: wxscintilla.h,v 1.38 2006/09/22 19:42:14 wyo Exp $ +// Copyright: (c) 2004 wxCode +// Licence: wxWindows +///////////////////////////////////////////////////////////////////////////// + +#ifndef __WXSCINTILLA_H__ +#define __WXSCINTILLA_H__ + +#define wxSCINTILLA_VERSION _T("1.71.1") + +#include +#include + +#ifdef __APPLE__ +#include "Platform.h" +#endif + +#ifdef WXDLLIMPEXP_SCI +#undef WXDLLIMPEXP_SCI +#endif + +#ifdef WXMAKINGDLL_SCI + #define WXDLLIMPEXP_SCI WXEXPORT +#elif defined(WXUSINGDLL_SCI) + #define WXDLLIMPEXP_SCI WXIMPORT +#else // not making nor using DLL + #define WXDLLIMPEXP_SCI +#endif + +// SWIG can't handle "#if" type of conditionals, only "#ifdef" +#ifdef SWIG +#define SCI_USE_DND 1 +#else +#if wxUSE_DRAG_AND_DROP +#define SCI_USE_DND 1 +#endif +#endif + +//---------------------------------------------------------------------- + +// Should a wxPopupWindow be used for the call tips and autocomplete windows? +#ifndef wxSCI_USE_POPUP +#define wxSCI_USE_POPUP 1 +#endif + +//---------------------------------------------------------------------- +// BEGIN generated section. The following code is automatically generated +// by gen_iface.py. Do not edit this file. Edit wxscintilla.h.in instead +// and regenerate + +#define wxSCI_INVALID_POSITION -1 + +// Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages +// as many EM_ messages can be used although that use is deprecated. +#define wxSCI_START 2000 +#define wxSCI_OPTIONAL_START 3000 +#define wxSCI_LEXER_START 4000 +#define wxSCI_WS_INVISIBLE 0 +#define wxSCI_WS_VISIBLEALWAYS 1 +#define wxSCI_WS_VISIBLEAFTERINDENT 2 +#define wxSCI_WS_INDENTVISIBLE 3 +#define wxSCI_EOL_CRLF 0 +#define wxSCI_EOL_CR 1 +#define wxSCI_EOL_LF 2 + +// The SC_CP_UTF8 value can be used to enter Unicode mode. +// This is the same value as CP_UTF8 in Windows +#define wxSCI_CP_UTF8 65001 + +// The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+. +#define wxSCI_CP_DBCS 1 + +#define wxSCI_MARKER_MAX 31 +#define wxSCI_MARK_CIRCLE 0 +#define wxSCI_MARK_ROUNDRECT 1 +#define wxSCI_MARK_ARROW 2 +#define wxSCI_MARK_SMALLRECT 3 +#define wxSCI_MARK_SHORTARROW 4 +#define wxSCI_MARK_EMPTY 5 +#define wxSCI_MARK_ARROWDOWN 6 +#define wxSCI_MARK_MINUS 7 +#define wxSCI_MARK_PLUS 8 + +// Shapes used for outlining column. +#define wxSCI_MARK_VLINE 9 +#define wxSCI_MARK_LCORNER 10 +#define wxSCI_MARK_TCORNER 11 +#define wxSCI_MARK_BOXPLUS 12 +#define wxSCI_MARK_BOXPLUSCONNECTED 13 +#define wxSCI_MARK_BOXMINUS 14 +#define wxSCI_MARK_BOXMINUSCONNECTED 15 +#define wxSCI_MARK_LCORNERCURVE 16 +#define wxSCI_MARK_TCORNERCURVE 17 +#define wxSCI_MARK_CIRCLEPLUS 18 +#define wxSCI_MARK_CIRCLEPLUSCONNECTED 19 +#define wxSCI_MARK_CIRCLEMINUS 20 +#define wxSCI_MARK_CIRCLEMINUSCONNECTED 21 + +// Invisible mark that only sets the line background color. +#define wxSCI_MARK_BACKGROUND 22 +#define wxSCI_MARK_DOTDOTDOT 23 +#define wxSCI_MARK_ARROWS 24 +#define wxSCI_MARK_PIXMAP 25 +#define wxSCI_MARK_FULLRECT 26 +#define wxSCI_MARK_ARROW_IN_BOX 100 +#define wxSCI_MARK_ARROWDOWN_IN_BOX 101 +#define wxSCI_MARK_FULLRECT_TAIL 102 +#define wxSCI_MARK_PLUS_IN_BOX 103 +#define wxSCI_MARK_MINUS_IN_BOX 104 +#define wxSCI_MARK_CHARACTER 10000 + +// Markers used for outlining column. +#define wxSCI_MARKNUM_FOLDEREND 25 +#define wxSCI_MARKNUM_FOLDEROPENMID 26 +#define wxSCI_MARKNUM_FOLDERMIDTAIL 27 +#define wxSCI_MARKNUM_FOLDERTAIL 28 +#define wxSCI_MARKNUM_FOLDERSUB 29 +#define wxSCI_MARKNUM_FOLDER 30 +#define wxSCI_MARKNUM_FOLDEROPEN 31 +#define wxSCI_MASK_FOLDERS 0xFE000000 +#define wxSCI_MARGIN_SYMBOL 0 +#define wxSCI_MARGIN_NUMBER 1 +#define wxSCI_MARGIN_BACK 2 +#define wxSCI_MARGIN_FORE 3 +#define wxSCI_MARGIN_TEXT 4 +#define wxSCI_MARGIN_RTEXT 5 + +// Styles in range 32..38 are predefined for parts of the UI and are not used as normal styles. +// Styles 39 is for future use. +#define wxSCI_STYLE_DEFAULT 32 +#define wxSCI_STYLE_LINENUMBER 33 +#define wxSCI_STYLE_BRACELIGHT 34 +#define wxSCI_STYLE_BRACEBAD 35 +#define wxSCI_STYLE_CONTROLCHAR 36 +#define wxSCI_STYLE_INDENTGUIDE 37 +#define wxSCI_STYLE_CALLTIP 38 +#define wxSCI_STYLE_LASTPREDEFINED 39 +#define wxSCI_STYLE_MAX 127 + +// Character set identifiers are used in StyleSetCharacterSet. +// The values are the same as the Windows *_CHARSET values. +#define wxSCI_CHARSET_ANSI 0 +#define wxSCI_CHARSET_DEFAULT 1 +#define wxSCI_CHARSET_BALTIC 186 +#define wxSCI_CHARSET_CHINESEBIG5 136 +#define wxSCI_CHARSET_EASTEUROPE 238 +#define wxSCI_CHARSET_GB2312 134 +#define wxSCI_CHARSET_GREEK 161 +#define wxSCI_CHARSET_HANGUL 129 +#define wxSCI_CHARSET_MAC 77 +#define wxSCI_CHARSET_OEM 255 +#define wxSCI_CHARSET_RUSSIAN 204 +#define wxSCI_CHARSET_CYRILLIC 1251 +#define wxSCI_CHARSET_SHIFTJIS 128 +#define wxSCI_CHARSET_SYMBOL 2 +#define wxSCI_CHARSET_TURKISH 162 +#define wxSCI_CHARSET_JOHAB 130 +#define wxSCI_CHARSET_HEBREW 177 +#define wxSCI_CHARSET_ARABIC 178 +#define wxSCI_CHARSET_VIETNAMESE 163 +#define wxSCI_CHARSET_THAI 222 +#define wxSCI_CHARSET_8859_15 1000 +#define wxSCI_CASE_MIXED 0 +#define wxSCI_CASE_UPPER 1 +#define wxSCI_CASE_LOWER 2 +#define wxSCI_INDIC_MAX 7 +#define wxSCI_INDIC_PLAIN 0 +#define wxSCI_INDIC_SQUIGGLE 1 +#define wxSCI_INDIC_TT 2 +#define wxSCI_INDIC_DIAGONAL 3 +#define wxSCI_INDIC_STRIKE 4 +#define wxSCI_INDIC_HIDDEN 5 +#define wxSCI_INDIC_BOX 6 +#define wxSCI_INDIC_ROUNDBOX 7 +#define wxSCI_INDIC0_MASK 0x20 +#define wxSCI_INDIC1_MASK 0x40 +#define wxSCI_INDIC2_MASK 0x80 +#define wxSCI_INDICS_MASK 0xE0 + +// PrintColourMode - use same colours as screen. +#define wxSCI_PRINT_NORMAL 0 + +// PrintColourMode - invert the light value of each style for printing. +#define wxSCI_PRINT_INVERTLIGHT 1 + +// PrintColourMode - force black text on white background for printing. +#define wxSCI_PRINT_BLACKONWHITE 2 + +// PrintColourMode - text stays coloured, but all background is forced to be white for printing. +#define wxSCI_PRINT_COLOURONWHITE 3 + +// PrintColourMode - only the default-background is forced to be white for printing. +#define wxSCI_PRINT_COLOURONWHITEDEFAULTBG 4 +#define wxSCI_FIND_WHOLEWORD 2 +#define wxSCI_FIND_MATCHCASE 4 +#define wxSCI_FIND_WORDSTART 0x00100000 +#define wxSCI_FIND_REGEXP 0x00200000 +#define wxSCI_FIND_POSIX 0x00400000 +#define wxSCI_FOLDLEVELBASE 0x400 +#define wxSCI_FOLDLEVELWHITEFLAG 0x1000 +#define wxSCI_FOLDLEVELHEADERFLAG 0x2000 +#define wxSCI_FOLDLEVELBOXHEADERFLAG 0x4000 +#define wxSCI_FOLDLEVELBOXFOOTERFLAG 0x8000 +#define wxSCI_FOLDLEVELCONTRACTED 0x10000 +#define wxSCI_FOLDLEVELUNINDENT 0x20000 +#define wxSCI_FOLDLEVELNUMBERMASK 0x0FFF +#define wxSCI_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002 +#define wxSCI_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004 +#define wxSCI_FOLDFLAG_LINEAFTER_EXPANDED 0x0008 +#define wxSCI_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010 +#define wxSCI_FOLDFLAG_LEVELNUMBERS 0x0040 +#define wxSCI_FOLDFLAG_BOX 0x0001 +#define wxSCI_TIME_FOREVER 10000000 +#define wxSCI_WRAP_NONE 0 +#define wxSCI_WRAP_WORD 1 +#define wxSCI_WRAP_CHAR 2 +#define wxSCI_WRAPVISUALFLAG_NONE 0x0000 +#define wxSCI_WRAPVISUALFLAG_END 0x0001 +#define wxSCI_WRAPVISUALFLAG_START 0x0002 +#define wxSCI_WRAPVISUALFLAGLOC_DEFAULT 0x0000 +#define wxSCI_WRAPVISUALFLAGLOC_END_BY_TEXT 0x0001 +#define wxSCI_WRAPVISUALFLAGLOC_START_BY_TEXT 0x0002 +#define wxSCI_CACHE_NONE 0 +#define wxSCI_CACHE_CARET 1 +#define wxSCI_CACHE_PAGE 2 +#define wxSCI_CACHE_DOCUMENT 3 +#define wxSCI_EDGE_NONE 0 +#define wxSCI_EDGE_LINE 1 +#define wxSCI_EDGE_BACKGROUND 2 +#define wxSCI_CURSORNORMAL -1 +#define wxSCI_CURSORWAIT 4 + +// Constants for use with SetVisiblePolicy, similar to SetCaretPolicy. +#define wxSCI_VISIBLE_SLOP 0x01 +#define wxSCI_VISIBLE_STRICT 0x04 + +// Caret policy, used by SetXCaretPolicy and SetYCaretPolicy. +// If CARET_SLOP is set, we can define a slop value: caretSlop. +// This value defines an unwanted zone (UZ) where the caret is... unwanted. +// This zone is defined as a number of pixels near the vertical margins, +// and as a number of lines near the horizontal margins. +// By keeping the caret away from the edges, it is seen within its context, +// so it is likely that the identifier that the caret is on can be completely seen, +// and that the current line is seen with some of the lines following it which are +// often dependent on that line. +#define wxSCI_CARET_SLOP 0x01 + +// If CARET_STRICT is set, the policy is enforced... strictly. +// The caret is centred on the display if slop is not set, +// and cannot go in the UZ if slop is set. +#define wxSCI_CARET_STRICT 0x04 + +// If CARET_JUMPS is set, the display is moved more energetically +// so the caret can move in the same direction longer before the policy is applied again. +#define wxSCI_CARET_JUMPS 0x10 + +// If CARET_EVEN is not set, instead of having symmetrical UZs, +// the left and bottom UZs are extended up to right and top UZs respectively. +// This way, we favour the displaying of useful information: the begining of lines, +// where most code reside, and the lines after the caret, eg. the body of a function. +#define wxSCI_CARET_EVEN 0x08 + +// Selection modes +#define wxSCI_SEL_STREAM 0 +#define wxSCI_SEL_RECTANGLE 1 +#define wxSCI_SEL_LINES 2 + +// Maximum value of keywordSet parameter of SetKeyWords. +#define wxSCI_KEYWORDSET_MAX 8 + +// Notifications +// Type of modification and the action which caused the modification. +// These are defined as a bit mask to make it easy to specify which notifications are wanted. +// One bit is set from each of SC_MOD_* and SC_PERFORMED_*. +#define wxSCI_MOD_INSERTTEXT 0x1 +#define wxSCI_MOD_DELETETEXT 0x2 +#define wxSCI_MOD_CHANGESTYLE 0x4 +#define wxSCI_MOD_CHANGEFOLD 0x8 +#define wxSCI_PERFORMED_USER 0x10 +#define wxSCI_PERFORMED_UNDO 0x20 +#define wxSCI_PERFORMED_REDO 0x40 +#define wxSCI_MULTISTEPUNDOREDO 0x80 +#define wxSCI_LASTSTEPINUNDOREDO 0x100 +#define wxSCI_MOD_CHANGEMARKER 0x200 +#define wxSCI_MOD_BEFOREINSERT 0x400 +#define wxSCI_MOD_BEFOREDELETE 0x800 +#define wxSCI_MULTILINEUNDOREDO 0x1000 +#define wxSCI_MODEVENTMASKALL 0x1FFF + +// Symbolic key codes and modifier flags. +// ASCII and other printable characters below 256. +// Extended keys above 300. +#define wxSCI_KEY_DOWN 300 +#define wxSCI_KEY_UP 301 +#define wxSCI_KEY_LEFT 302 +#define wxSCI_KEY_RIGHT 303 +#define wxSCI_KEY_HOME 304 +#define wxSCI_KEY_END 305 +#define wxSCI_KEY_PRIOR 306 +#define wxSCI_KEY_NEXT 307 +#define wxSCI_KEY_DELETE 308 +#define wxSCI_KEY_INSERT 309 +#define wxSCI_KEY_ESCAPE 7 +#define wxSCI_KEY_BACK 8 +#define wxSCI_KEY_TAB 9 +#define wxSCI_KEY_RETURN 13 +#define wxSCI_KEY_ADD 310 +#define wxSCI_KEY_SUBTRACT 311 +#define wxSCI_KEY_DIVIDE 312 +#define wxSCI_SCMOD_NULL 0 +#define wxSCI_SCMOD_SHIFT 1 +#define wxSCI_SCMOD_CTRL 2 +#define wxSCI_SCMOD_ALT 4 + +// Caret line alpha background +#define wxSCI_ALPHA_TRANSPARENT 0 +#define wxSCI_ALPHA_OPAQUE 255 +#define wxSCI_ALPHA_NOALPHA 256 + +// For SciLexer.h +#define wxSCI_LEX_CONTAINER 0 +#define wxSCI_LEX_NULL 1 +#define wxSCI_LEX_PYTHON 2 +#define wxSCI_LEX_CPP 3 +#define wxSCI_LEX_HTML 4 +#define wxSCI_LEX_XML 5 +#define wxSCI_LEX_PERL 6 +#define wxSCI_LEX_SQL 7 +#define wxSCI_LEX_VB 8 +#define wxSCI_LEX_PROPERTIES 9 +#define wxSCI_LEX_ERRORLIST 10 +#define wxSCI_LEX_MAKEFILE 11 +#define wxSCI_LEX_BATCH 12 +#define wxSCI_LEX_XCODE 13 +#define wxSCI_LEX_LATEX 14 +#define wxSCI_LEX_LUA 15 +#define wxSCI_LEX_DIFF 16 +#define wxSCI_LEX_CONF 17 +#define wxSCI_LEX_PASCAL 18 +#define wxSCI_LEX_AVE 19 +#define wxSCI_LEX_ADA 20 +#define wxSCI_LEX_LISP 21 +#define wxSCI_LEX_RUBY 22 +#define wxSCI_LEX_EIFFEL 23 +#define wxSCI_LEX_EIFFELKW 24 +#define wxSCI_LEX_TCL 25 +#define wxSCI_LEX_NNCRONTAB 26 +#define wxSCI_LEX_BULLANT 27 +#define wxSCI_LEX_VBSCRIPT 28 +#define wxSCI_LEX_BAAN 31 +#define wxSCI_LEX_MATLAB 32 +#define wxSCI_LEX_SCRIPTOL 33 +#define wxSCI_LEX_ASM 34 +#define wxSCI_LEX_CPPNOCASE 35 +#define wxSCI_LEX_FORTRAN 36 +#define wxSCI_LEX_F77 37 +#define wxSCI_LEX_CSS 38 +#define wxSCI_LEX_POV 39 +#define wxSCI_LEX_LOUT 40 +#define wxSCI_LEX_ESCRIPT 41 +#define wxSCI_LEX_PS 42 +#define wxSCI_LEX_NSIS 43 +#define wxSCI_LEX_MMIXAL 44 +#define wxSCI_LEX_CLW 45 +#define wxSCI_LEX_CLWNOCASE 46 +#define wxSCI_LEX_LOT 47 +#define wxSCI_LEX_YAML 48 +#define wxSCI_LEX_TEX 49 +#define wxSCI_LEX_METAPOST 50 +#define wxSCI_LEX_POWERBASIC 51 +#define wxSCI_LEX_FORTH 52 +#define wxSCI_LEX_ERLANG 53 +#define wxSCI_LEX_OCTAVE 54 +#define wxSCI_LEX_MSSQL 55 +#define wxSCI_LEX_VERILOG 56 +#define wxSCI_LEX_KIX 57 +#define wxSCI_LEX_GUI4CLI 58 +#define wxSCI_LEX_SPECMAN 59 +#define wxSCI_LEX_AU3 60 +#define wxSCI_LEX_APDL 61 +#define wxSCI_LEX_BASH 62 +#define wxSCI_LEX_ASN1 63 +#define wxSCI_LEX_VHDL 64 +#define wxSCI_LEX_CAML 65 +#define wxSCI_LEX_BLITZBASIC 66 +#define wxSCI_LEX_PUREBASIC 67 +#define wxSCI_LEX_HASKELL 68 +#define wxSCI_LEX_PHPSCRIPT 69 +#define wxSCI_LEX_TADS3 70 +#define wxSCI_LEX_REBOL 71 +#define wxSCI_LEX_SMALLTALK 72 +#define wxSCI_LEX_FLAGSHIP 73 +#define wxSCI_LEX_CSOUND 74 +#define wxSCI_LEX_FREEBASIC 75 +#define wxSCI_LEX_INNOSETUP 76 +#define wxSCI_LEX_OPAL 77 +#define wxSCI_LEX_SPICE 78 +#define wxSCI_LEX_D 79 +#define wxSCI_LEX_CMAKE 80 +#define wxSCI_LEX_GAP 81 +#define wxSCI_LEX_PLM 82 +#define wxSCI_LEX_PROGRESS 83 +#define wxSCI_LEX_ABAQUS 84 +#define wxSCI_LEX_ASYMPTOTE 85 +#define wxSCI_LEX_R 86 +#define wxSCI_LEX_MAGIK 87 +#define wxSCI_LEX_POWERSHELL 88 + +//ERAN +#define wxSCI_LEX_GCC 150 +#define wxSCI_LEX_CPPCHECK 153 +#define wxSCI_LEX_GCC_DEFAULT 0 +#define wxSCI_LEX_GCC_ERROR 1 +#define wxSCI_LEX_GCC_WARNING 2 +#define wxSCI_LEX_GCC_BUILDING 3 +#define wxSCI_LEX_GCC_FILE_LINK 4 +#define wxSCI_LEX_GCC_OUTPUT 5 +#define wxSCI_LEX_GCC_MAKE_ENTER 6 +#define wxSCI_LEX_GCC_MAKE_LEAVING 7 + +#define wxSCI_LEX_FIF 151 +#define wxSCI_LEX_FIF_DEFAULT 0 +#define wxSCI_LEX_FIF_FILE 1 +#define wxSCI_LEX_FIF_MATCH 2 +#define wxSCI_LEX_FIF_FILE_SHORT 3 +#define wxSCI_LEX_FIF_PROJECT 4 +#define wxSCI_LEX_FIF_SCOPE 5 + +#define wxSCI_LEX_SVN 152 +#define wxSCI_LEX_SVN_DEFAULT 0 +#define wxSCI_LEX_SVN_UPDATED 1 +#define wxSCI_LEX_SVN_CONFLICT 2 +#define wxSCI_LEX_SVN_MERGED 3 +#define wxSCI_LEX_SVN_DELETED 4 +#define wxSCI_LEX_SVN_ADDED 5 +#define wxSCI_LEX_SVN_INFO 6 + +//ERAN - END + +//EPOCH - START +#define wxSCI_LEX_ALTARICA 154 +#define wxSCI_ALTARICA_DEFAULT 0 +#define wxSCI_ALTARICA_COMMENT 1 +#define wxSCI_ALTARICA_COMMENTLINE 2 +#define wxSCI_ALTARICA_KEYWORD 3 +#define wxSCI_ALTARICA_TYPE 4 +#define wxSCI_ALTARICA_IDENTIFIER 5 +#define wxSCI_ALTARICA_OPERATOR 6 +#define wxSCI_ALTARICA_NUMBER 7 +#define wxSCI_ALTARICA_FORBIDDEN 8 + +#define wxSCI_LEX_PRISM 155 +#define wxSCI_PRISM_DEFAULT 0 +#define wxSCI_PRISM_COMMENT 1 +#define wxSCI_PRISM_KEYWORD 2 +#define wxSCI_PRISM_FUNCTION 3 +#define wxSCI_PRISM_TYPE 4 +#define wxSCI_PRISM_IDENTIFIER 5 +#define wxSCI_PRISM_OPERATOR 6 +#define wxSCI_PRISM_NUMBER 7 +#define wxSCI_PRISM_STRING 8 +#define wxSCI_PRISM_FORBIDDEN 9 +//EPOCH - END + +// When a lexer specifies its language as SCLEX_AUTOMATIC it receives a +// value assigned in sequence from SCLEX_AUTOMATIC+1. +#define wxSCI_LEX_AUTOMATIC 1000 + +// Lexical states for SCLEX_PYTHON +#define wxSCI_P_DEFAULT 0 +#define wxSCI_P_COMMENTLINE 1 +#define wxSCI_P_NUMBER 2 +#define wxSCI_P_STRING 3 +#define wxSCI_P_CHARACTER 4 +#define wxSCI_P_WORD 5 +#define wxSCI_P_TRIPLE 6 +#define wxSCI_P_TRIPLEDOUBLE 7 +#define wxSCI_P_CLASSNAME 8 +#define wxSCI_P_DEFNAME 9 +#define wxSCI_P_OPERATOR 10 +#define wxSCI_P_IDENTIFIER 11 +#define wxSCI_P_COMMENTBLOCK 12 +#define wxSCI_P_STRINGEOL 13 +#define wxSCI_P_WORD2 14 +#define wxSCI_P_DECORATOR 15 + +// Lexical states for SCLEX_CPP +#define wxSCI_C_DEFAULT 0 +#define wxSCI_C_COMMENT 1 +#define wxSCI_C_COMMENTLINE 2 +#define wxSCI_C_COMMENTDOC 3 +#define wxSCI_C_NUMBER 4 +#define wxSCI_C_WORD 5 +#define wxSCI_C_STRING 6 +#define wxSCI_C_CHARACTER 7 +#define wxSCI_C_UUID 8 +#define wxSCI_C_PREPROCESSOR 9 +#define wxSCI_C_OPERATOR 10 +#define wxSCI_C_IDENTIFIER 11 +#define wxSCI_C_STRINGEOL 12 +#define wxSCI_C_VERBATIM 13 +#define wxSCI_C_REGEX 14 +#define wxSCI_C_COMMENTLINEDOC 15 +#define wxSCI_C_WORD2 16 +#define wxSCI_C_COMMENTDOCKEYWORD 17 +#define wxSCI_C_COMMENTDOCKEYWORDERROR 18 +#define wxSCI_C_GLOBALCLASS 19 + +// Lexical states for SCLEX_TCL +#define wxSCI_TCL_DEFAULT 0 +#define wxSCI_TCL_COMMENT 1 +#define wxSCI_TCL_COMMENTLINE 2 +#define wxSCI_TCL_NUMBER 3 +#define wxSCI_TCL_WORD_IN_QUOTE 4 +#define wxSCI_TCL_IN_QUOTE 5 +#define wxSCI_TCL_OPERATOR 6 +#define wxSCI_TCL_IDENTIFIER 7 +#define wxSCI_TCL_SUBSTITUTION 8 +#define wxSCI_TCL_SUB_BRACE 9 +#define wxSCI_TCL_MODIFIER 10 +#define wxSCI_TCL_EXPAND 11 +#define wxSCI_TCL_WORD 12 +#define wxSCI_TCL_WORD2 13 +#define wxSCI_TCL_WORD3 14 +#define wxSCI_TCL_WORD4 15 +#define wxSCI_TCL_WORD5 16 +#define wxSCI_TCL_WORD6 17 +#define wxSCI_TCL_WORD7 18 +#define wxSCI_TCL_WORD8 19 +#define wxSCI_TCL_COMMENT_BOX 20 +#define wxSCI_TCL_BLOCK_COMMENT 21 + +// Lexical states for SCLEX_HTML, SCLEX_XML +#define wxSCI_H_DEFAULT 0 +#define wxSCI_H_TAG 1 +#define wxSCI_H_TAGUNKNOWN 2 +#define wxSCI_H_ATTRIBUTE 3 +#define wxSCI_H_ATTRIBUTEUNKNOWN 4 +#define wxSCI_H_NUMBER 5 +#define wxSCI_H_DOUBLESTRING 6 +#define wxSCI_H_SINGLESTRING 7 +#define wxSCI_H_OTHER 8 +#define wxSCI_H_COMMENT 9 +#define wxSCI_H_ENTITY 10 + +// XML and ASP +#define wxSCI_H_TAGEND 11 +#define wxSCI_H_XMLSTART 12 +#define wxSCI_H_XMLEND 13 +#define wxSCI_H_SCRIPT 14 +#define wxSCI_H_ASP 15 +#define wxSCI_H_ASPAT 16 +#define wxSCI_H_CDATA 17 +#define wxSCI_H_QUESTION 18 + +// More HTML +#define wxSCI_H_VALUE 19 + +// X-Code +#define wxSCI_H_XCCOMMENT 20 + +// SGML +#define wxSCI_H_SGML_DEFAULT 21 +#define wxSCI_H_SGML_COMMAND 22 +#define wxSCI_H_SGML_1ST_PARAM 23 +#define wxSCI_H_SGML_DOUBLESTRING 24 +#define wxSCI_H_SGML_SIMPLESTRING 25 +#define wxSCI_H_SGML_ERROR 26 +#define wxSCI_H_SGML_SPECIAL 27 +#define wxSCI_H_SGML_ENTITY 28 +#define wxSCI_H_SGML_COMMENT 29 +#define wxSCI_H_SGML_1ST_PARAM_COMMENT 30 +#define wxSCI_H_SGML_BLOCK_DEFAULT 31 + +// Embedded Javascript +#define wxSCI_HJ_START 40 +#define wxSCI_HJ_DEFAULT 41 +#define wxSCI_HJ_COMMENT 42 +#define wxSCI_HJ_COMMENTLINE 43 +#define wxSCI_HJ_COMMENTDOC 44 +#define wxSCI_HJ_NUMBER 45 +#define wxSCI_HJ_WORD 46 +#define wxSCI_HJ_KEYWORD 47 +#define wxSCI_HJ_DOUBLESTRING 48 +#define wxSCI_HJ_SINGLESTRING 49 +#define wxSCI_HJ_SYMBOLS 50 +#define wxSCI_HJ_STRINGEOL 51 +#define wxSCI_HJ_REGEX 52 + +// ASP Javascript +#define wxSCI_HJA_START 55 +#define wxSCI_HJA_DEFAULT 56 +#define wxSCI_HJA_COMMENT 57 +#define wxSCI_HJA_COMMENTLINE 58 +#define wxSCI_HJA_COMMENTDOC 59 +#define wxSCI_HJA_NUMBER 60 +#define wxSCI_HJA_WORD 61 +#define wxSCI_HJA_KEYWORD 62 +#define wxSCI_HJA_DOUBLESTRING 63 +#define wxSCI_HJA_SINGLESTRING 64 +#define wxSCI_HJA_SYMBOLS 65 +#define wxSCI_HJA_STRINGEOL 66 +#define wxSCI_HJA_REGEX 67 + +// Embedded VBScript +#define wxSCI_HB_START 70 +#define wxSCI_HB_DEFAULT 71 +#define wxSCI_HB_COMMENTLINE 72 +#define wxSCI_HB_NUMBER 73 +#define wxSCI_HB_WORD 74 +#define wxSCI_HB_STRING 75 +#define wxSCI_HB_IDENTIFIER 76 +#define wxSCI_HB_STRINGEOL 77 + +// ASP VBScript +#define wxSCI_HBA_START 80 +#define wxSCI_HBA_DEFAULT 81 +#define wxSCI_HBA_COMMENTLINE 82 +#define wxSCI_HBA_NUMBER 83 +#define wxSCI_HBA_WORD 84 +#define wxSCI_HBA_STRING 85 +#define wxSCI_HBA_IDENTIFIER 86 +#define wxSCI_HBA_STRINGEOL 87 + +// Embedded Python +#define wxSCI_HP_START 90 +#define wxSCI_HP_DEFAULT 91 +#define wxSCI_HP_COMMENTLINE 92 +#define wxSCI_HP_NUMBER 93 +#define wxSCI_HP_STRING 94 +#define wxSCI_HP_CHARACTER 95 +#define wxSCI_HP_WORD 96 +#define wxSCI_HP_TRIPLE 97 +#define wxSCI_HP_TRIPLEDOUBLE 98 +#define wxSCI_HP_CLASSNAME 99 +#define wxSCI_HP_DEFNAME 100 +#define wxSCI_HP_OPERATOR 101 +#define wxSCI_HP_IDENTIFIER 102 + +// PHP +#define wxSCI_HPHP_COMPLEX_VARIABLE 104 + +// ASP Python +#define wxSCI_HPA_START 105 +#define wxSCI_HPA_DEFAULT 106 +#define wxSCI_HPA_COMMENTLINE 107 +#define wxSCI_HPA_NUMBER 108 +#define wxSCI_HPA_STRING 109 +#define wxSCI_HPA_CHARACTER 110 +#define wxSCI_HPA_WORD 111 +#define wxSCI_HPA_TRIPLE 112 +#define wxSCI_HPA_TRIPLEDOUBLE 113 +#define wxSCI_HPA_CLASSNAME 114 +#define wxSCI_HPA_DEFNAME 115 +#define wxSCI_HPA_OPERATOR 116 +#define wxSCI_HPA_IDENTIFIER 117 + +// PHP +#define wxSCI_HPHP_DEFAULT 118 +#define wxSCI_HPHP_HSTRING 119 +#define wxSCI_HPHP_SIMPLESTRING 120 +#define wxSCI_HPHP_WORD 121 +#define wxSCI_HPHP_NUMBER 122 +#define wxSCI_HPHP_VARIABLE 123 +#define wxSCI_HPHP_COMMENT 124 +#define wxSCI_HPHP_COMMENTLINE 125 +#define wxSCI_HPHP_HSTRING_VARIABLE 126 +#define wxSCI_HPHP_OPERATOR 127 + +// Lexical states for SCLEX_PERL +#define wxSCI_PL_DEFAULT 0 +#define wxSCI_PL_ERROR 1 +#define wxSCI_PL_COMMENTLINE 2 +#define wxSCI_PL_POD 3 +#define wxSCI_PL_NUMBER 4 +#define wxSCI_PL_WORD 5 +#define wxSCI_PL_STRING 6 +#define wxSCI_PL_CHARACTER 7 +#define wxSCI_PL_PUNCTUATION 8 +#define wxSCI_PL_PREPROCESSOR 9 +#define wxSCI_PL_OPERATOR 10 +#define wxSCI_PL_IDENTIFIER 11 +#define wxSCI_PL_SCALAR 12 +#define wxSCI_PL_ARRAY 13 +#define wxSCI_PL_HASH 14 +#define wxSCI_PL_SYMBOLTABLE 15 +#define wxSCI_PL_VARIABLE_INDEXER 16 +#define wxSCI_PL_REGEX 17 +#define wxSCI_PL_REGSUBST 18 +#define wxSCI_PL_LONGQUOTE 19 +#define wxSCI_PL_BACKTICKS 20 +#define wxSCI_PL_DATASECTION 21 +#define wxSCI_PL_HERE_DELIM 22 +#define wxSCI_PL_HERE_Q 23 +#define wxSCI_PL_HERE_QQ 24 +#define wxSCI_PL_HERE_QX 25 +#define wxSCI_PL_STRING_Q 26 +#define wxSCI_PL_STRING_QQ 27 +#define wxSCI_PL_STRING_QX 28 +#define wxSCI_PL_STRING_QR 29 +#define wxSCI_PL_STRING_QW 30 +#define wxSCI_PL_POD_VERB 31 + +// Lexical states for SCLEX_RUBY +#define wxSCI_RB_DEFAULT 0 +#define wxSCI_RB_ERROR 1 +#define wxSCI_RB_COMMENTLINE 2 +#define wxSCI_RB_POD 3 +#define wxSCI_RB_NUMBER 4 +#define wxSCI_RB_WORD 5 +#define wxSCI_RB_STRING 6 +#define wxSCI_RB_CHARACTER 7 +#define wxSCI_RB_CLASSNAME 8 +#define wxSCI_RB_DEFNAME 9 +#define wxSCI_RB_OPERATOR 10 +#define wxSCI_RB_IDENTIFIER 11 +#define wxSCI_RB_REGEX 12 +#define wxSCI_RB_GLOBAL 13 +#define wxSCI_RB_SYMBOL 14 +#define wxSCI_RB_MODULE_NAME 15 +#define wxSCI_RB_INSTANCE_VAR 16 +#define wxSCI_RB_CLASS_VAR 17 +#define wxSCI_RB_BACKTICKS 18 +#define wxSCI_RB_DATASECTION 19 +#define wxSCI_RB_HERE_DELIM 20 +#define wxSCI_RB_HERE_Q 21 +#define wxSCI_RB_HERE_QQ 22 +#define wxSCI_RB_HERE_QX 23 +#define wxSCI_RB_STRING_Q 24 +#define wxSCI_RB_STRING_QQ 25 +#define wxSCI_RB_STRING_QX 26 +#define wxSCI_RB_STRING_QR 27 +#define wxSCI_RB_STRING_QW 28 +#define wxSCI_RB_WORD_DEMOTED 29 +#define wxSCI_RB_STDIN 30 +#define wxSCI_RB_STDOUT 31 +#define wxSCI_RB_STDERR 40 +#define wxSCI_RB_UPPER_BOUND 41 + +// Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC +#define wxSCI_B_DEFAULT 0 +#define wxSCI_B_COMMENT 1 +#define wxSCI_B_NUMBER 2 +#define wxSCI_B_KEYWORD 3 +#define wxSCI_B_STRING 4 +#define wxSCI_B_PREPROCESSOR 5 +#define wxSCI_B_OPERATOR 6 +#define wxSCI_B_IDENTIFIER 7 +#define wxSCI_B_DATE 8 +#define wxSCI_B_STRINGEOL 9 +#define wxSCI_B_KEYWORD2 10 +#define wxSCI_B_KEYWORD3 11 +#define wxSCI_B_KEYWORD4 12 +#define wxSCI_B_CONSTANT 13 +#define wxSCI_B_ASM 14 +#define wxSCI_B_LABEL 15 +#define wxSCI_B_ERROR 16 +#define wxSCI_B_HEXNUMBER 17 +#define wxSCI_B_BINNUMBER 18 + +// Lexical states for SCLEX_PROPERTIES +#define wxSCI_PROPS_DEFAULT 0 +#define wxSCI_PROPS_COMMENT 1 +#define wxSCI_PROPS_SECTION 2 +#define wxSCI_PROPS_ASSIGNMENT 3 +#define wxSCI_PROPS_DEFVAL 4 +#define wxSCI_PROPS_KEY 5 + +// Lexical states for SCLEX_LATEX +#define wxSCI_L_DEFAULT 0 +#define wxSCI_L_COMMAND 1 +#define wxSCI_L_TAG 2 +#define wxSCI_L_MATH 3 +#define wxSCI_L_COMMENT 4 + +// Lexical states for SCLEX_LUA +#define wxSCI_LUA_DEFAULT 0 +#define wxSCI_LUA_COMMENT 1 +#define wxSCI_LUA_COMMENTLINE 2 +#define wxSCI_LUA_COMMENTDOC 3 +#define wxSCI_LUA_NUMBER 4 +#define wxSCI_LUA_WORD 5 +#define wxSCI_LUA_STRING 6 +#define wxSCI_LUA_CHARACTER 7 +#define wxSCI_LUA_LITERALSTRING 8 +#define wxSCI_LUA_PREPROCESSOR 9 +#define wxSCI_LUA_OPERATOR 10 +#define wxSCI_LUA_IDENTIFIER 11 +#define wxSCI_LUA_STRINGEOL 12 +#define wxSCI_LUA_WORD2 13 +#define wxSCI_LUA_WORD3 14 +#define wxSCI_LUA_WORD4 15 +#define wxSCI_LUA_WORD5 16 +#define wxSCI_LUA_WORD6 17 +#define wxSCI_LUA_WORD7 18 +#define wxSCI_LUA_WORD8 19 + +// Lexical states for SCLEX_ERRORLIST +#define wxSCI_ERR_DEFAULT 0 +#define wxSCI_ERR_PYTHON 1 +#define wxSCI_ERR_GCC 2 +#define wxSCI_ERR_MS 3 +#define wxSCI_ERR_CMD 4 +#define wxSCI_ERR_BORLAND 5 +#define wxSCI_ERR_PERL 6 +#define wxSCI_ERR_NET 7 +#define wxSCI_ERR_LUA 8 +#define wxSCI_ERR_CTAG 9 +#define wxSCI_ERR_DIFF_CHANGED 10 +#define wxSCI_ERR_DIFF_ADDITION 11 +#define wxSCI_ERR_DIFF_DELETION 12 +#define wxSCI_ERR_DIFF_MESSAGE 13 +#define wxSCI_ERR_PHP 14 +#define wxSCI_ERR_ELF 15 +#define wxSCI_ERR_IFC 16 +#define wxSCI_ERR_IFORT 17 +#define wxSCI_ERR_ABSF 18 +#define wxSCI_ERR_TIDY 19 +#define wxSCI_ERR_JAVA_STACK 20 + +// Lexical states for SCLEX_BATCH +#define wxSCI_BAT_DEFAULT 0 +#define wxSCI_BAT_COMMENT 1 +#define wxSCI_BAT_WORD 2 +#define wxSCI_BAT_LABEL 3 +#define wxSCI_BAT_HIDE 4 +#define wxSCI_BAT_COMMAND 5 +#define wxSCI_BAT_IDENTIFIER 6 +#define wxSCI_BAT_OPERATOR 7 + +// Lexical states for SCLEX_MAKEFILE +#define wxSCI_MAKE_DEFAULT 0 +#define wxSCI_MAKE_COMMENT 1 +#define wxSCI_MAKE_PREPROCESSOR 2 +#define wxSCI_MAKE_IDENTIFIER 3 +#define wxSCI_MAKE_OPERATOR 4 +#define wxSCI_MAKE_TARGET 5 +#define wxSCI_MAKE_IDEOL 9 + +// Lexical states for SCLEX_DIFF +#define wxSCI_DIFF_DEFAULT 0 +#define wxSCI_DIFF_COMMENT 1 +#define wxSCI_DIFF_COMMAND 2 +#define wxSCI_DIFF_HEADER 3 +#define wxSCI_DIFF_POSITION 4 +#define wxSCI_DIFF_DELETED 5 +#define wxSCI_DIFF_ADDED 6 + +// Lexical states for SCLEX_CONF (Apache Configuration Files Lexer) +#define wxSCI_CONF_DEFAULT 0 +#define wxSCI_CONF_COMMENT 1 +#define wxSCI_CONF_NUMBER 2 +#define wxSCI_CONF_IDENTIFIER 3 +#define wxSCI_CONF_EXTENSION 4 +#define wxSCI_CONF_PARAMETER 5 +#define wxSCI_CONF_STRING 6 +#define wxSCI_CONF_OPERATOR 7 +#define wxSCI_CONF_IP 8 +#define wxSCI_CONF_DIRECTIVE 9 + +// Lexical states for SCLEX_AVE, Avenue +#define wxSCI_AVE_DEFAULT 0 +#define wxSCI_AVE_COMMENT 1 +#define wxSCI_AVE_NUMBER 2 +#define wxSCI_AVE_WORD 3 +#define wxSCI_AVE_STRING 6 +#define wxSCI_AVE_ENUM 7 +#define wxSCI_AVE_STRINGEOL 8 +#define wxSCI_AVE_IDENTIFIER 9 +#define wxSCI_AVE_OPERATOR 10 +#define wxSCI_AVE_WORD1 11 +#define wxSCI_AVE_WORD2 12 +#define wxSCI_AVE_WORD3 13 +#define wxSCI_AVE_WORD4 14 +#define wxSCI_AVE_WORD5 15 +#define wxSCI_AVE_WORD6 16 + +// Lexical states for SCLEX_ADA +#define wxSCI_ADA_DEFAULT 0 +#define wxSCI_ADA_WORD 1 +#define wxSCI_ADA_IDENTIFIER 2 +#define wxSCI_ADA_NUMBER 3 +#define wxSCI_ADA_DELIMITER 4 +#define wxSCI_ADA_CHARACTER 5 +#define wxSCI_ADA_CHARACTEREOL 6 +#define wxSCI_ADA_STRING 7 +#define wxSCI_ADA_STRINGEOL 8 +#define wxSCI_ADA_LABEL 9 +#define wxSCI_ADA_COMMENTLINE 10 +#define wxSCI_ADA_ILLEGAL 11 + +// Lexical states for SCLEX_BAAN +#define wxSCI_BAAN_DEFAULT 0 +#define wxSCI_BAAN_COMMENT 1 +#define wxSCI_BAAN_COMMENTDOC 2 +#define wxSCI_BAAN_NUMBER 3 +#define wxSCI_BAAN_WORD 4 +#define wxSCI_BAAN_STRING 5 +#define wxSCI_BAAN_PREPROCESSOR 6 +#define wxSCI_BAAN_OPERATOR 7 +#define wxSCI_BAAN_IDENTIFIER 8 +#define wxSCI_BAAN_STRINGEOL 9 +#define wxSCI_BAAN_WORD2 10 + +// Lexical states for SCLEX_LISP +#define wxSCI_LISP_DEFAULT 0 +#define wxSCI_LISP_COMMENT 1 +#define wxSCI_LISP_NUMBER 2 +#define wxSCI_LISP_KEYWORD 3 +#define wxSCI_LISP_KEYWORD_KW 4 +#define wxSCI_LISP_SYMBOL 5 +#define wxSCI_LISP_STRING 6 +#define wxSCI_LISP_STRINGEOL 8 +#define wxSCI_LISP_IDENTIFIER 9 +#define wxSCI_LISP_OPERATOR 10 +#define wxSCI_LISP_SPECIAL 11 +#define wxSCI_LISP_MULTI_COMMENT 12 + +// Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW +#define wxSCI_EIFFEL_DEFAULT 0 +#define wxSCI_EIFFEL_COMMENTLINE 1 +#define wxSCI_EIFFEL_NUMBER 2 +#define wxSCI_EIFFEL_WORD 3 +#define wxSCI_EIFFEL_STRING 4 +#define wxSCI_EIFFEL_CHARACTER 5 +#define wxSCI_EIFFEL_OPERATOR 6 +#define wxSCI_EIFFEL_IDENTIFIER 7 +#define wxSCI_EIFFEL_STRINGEOL 8 + +// Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer) +#define wxSCI_NNCRONTAB_DEFAULT 0 +#define wxSCI_NNCRONTAB_COMMENT 1 +#define wxSCI_NNCRONTAB_TASK 2 +#define wxSCI_NNCRONTAB_SECTION 3 +#define wxSCI_NNCRONTAB_KEYWORD 4 +#define wxSCI_NNCRONTAB_MODIFIER 5 +#define wxSCI_NNCRONTAB_ASTERISK 6 +#define wxSCI_NNCRONTAB_NUMBER 7 +#define wxSCI_NNCRONTAB_STRING 8 +#define wxSCI_NNCRONTAB_ENVIRONMENT 9 +#define wxSCI_NNCRONTAB_IDENTIFIER 10 + +// Lexical states for SCLEX_FORTH (Forth Lexer) +#define wxSCI_FORTH_DEFAULT 0 +#define wxSCI_FORTH_COMMENT 1 +#define wxSCI_FORTH_COMMENT_ML 2 +#define wxSCI_FORTH_IDENTIFIER 3 +#define wxSCI_FORTH_CONTROL 4 +#define wxSCI_FORTH_KEYWORD 5 +#define wxSCI_FORTH_DEFWORD 6 +#define wxSCI_FORTH_PREWORD1 7 +#define wxSCI_FORTH_PREWORD2 8 +#define wxSCI_FORTH_NUMBER 9 +#define wxSCI_FORTH_STRING 10 +#define wxSCI_FORTH_LOCALE 11 + +// Lexical states for SCLEX_MATLAB +#define wxSCI_MATLAB_DEFAULT 0 +#define wxSCI_MATLAB_COMMENT 1 +#define wxSCI_MATLAB_COMMAND 2 +#define wxSCI_MATLAB_NUMBER 3 +#define wxSCI_MATLAB_KEYWORD 4 + +// single quoted string +#define wxSCI_MATLAB_STRING 5 +#define wxSCI_MATLAB_OPERATOR 6 +#define wxSCI_MATLAB_IDENTIFIER 7 +#define wxSCI_MATLAB_DOUBLEQUOTESTRING 8 + +// Lexical states for SCLEX_SCRIPTOL +#define wxSCI_SCRIPTOL_DEFAULT 0 +#define wxSCI_SCRIPTOL_WHITE 1 +#define wxSCI_SCRIPTOL_COMMENTLINE 2 +#define wxSCI_SCRIPTOL_PERSISTENT 3 +#define wxSCI_SCRIPTOL_CSTYLE 4 +#define wxSCI_SCRIPTOL_COMMENTBLOCK 5 +#define wxSCI_SCRIPTOL_NUMBER 6 +#define wxSCI_SCRIPTOL_STRING 7 +#define wxSCI_SCRIPTOL_CHARACTER 8 +#define wxSCI_SCRIPTOL_STRINGEOL 9 +#define wxSCI_SCRIPTOL_KEYWORD 10 +#define wxSCI_SCRIPTOL_OPERATOR 11 +#define wxSCI_SCRIPTOL_IDENTIFIER 12 +#define wxSCI_SCRIPTOL_TRIPLE 13 +#define wxSCI_SCRIPTOL_CLASSNAME 14 +#define wxSCI_SCRIPTOL_PREPROCESSOR 15 + +// Lexical states for SCLEX_ASM +#define wxSCI_ASM_DEFAULT 0 +#define wxSCI_ASM_COMMENT 1 +#define wxSCI_ASM_NUMBER 2 +#define wxSCI_ASM_STRING 3 +#define wxSCI_ASM_OPERATOR 4 +#define wxSCI_ASM_IDENTIFIER 5 +#define wxSCI_ASM_CPUINSTRUCTION 6 +#define wxSCI_ASM_MATHINSTRUCTION 7 +#define wxSCI_ASM_REGISTER 8 +#define wxSCI_ASM_DIRECTIVE 9 +#define wxSCI_ASM_DIRECTIVEOPERAND 10 +#define wxSCI_ASM_COMMENTBLOCK 11 +#define wxSCI_ASM_CHARACTER 12 +#define wxSCI_ASM_STRINGEOL 13 +#define wxSCI_ASM_EXTINSTRUCTION 14 + +// Lexical states for SCLEX_FORTRAN +#define wxSCI_F_DEFAULT 0 +#define wxSCI_F_COMMENT 1 +#define wxSCI_F_NUMBER 2 +#define wxSCI_F_STRING1 3 +#define wxSCI_F_STRING2 4 +#define wxSCI_F_STRINGEOL 5 +#define wxSCI_F_OPERATOR 6 +#define wxSCI_F_IDENTIFIER 7 +#define wxSCI_F_WORD 8 +#define wxSCI_F_WORD2 9 +#define wxSCI_F_WORD3 10 +#define wxSCI_F_PREPROCESSOR 11 +#define wxSCI_F_OPERATOR2 12 +#define wxSCI_F_LABEL 13 +#define wxSCI_F_CONTINUATION 14 + +// Lexical states for SCLEX_CSS +#define wxSCI_CSS_DEFAULT 0 +#define wxSCI_CSS_TAG 1 +#define wxSCI_CSS_CLASS 2 +#define wxSCI_CSS_PSEUDOCLASS 3 +#define wxSCI_CSS_UNKNOWN_PSEUDOCLASS 4 +#define wxSCI_CSS_OPERATOR 5 +#define wxSCI_CSS_IDENTIFIER 6 +#define wxSCI_CSS_UNKNOWN_IDENTIFIER 7 +#define wxSCI_CSS_VALUE 8 +#define wxSCI_CSS_COMMENT 9 +#define wxSCI_CSS_ID 10 +#define wxSCI_CSS_IMPORTANT 11 +#define wxSCI_CSS_DIRECTIVE 12 +#define wxSCI_CSS_DOUBLESTRING 13 +#define wxSCI_CSS_SINGLESTRING 14 +#define wxSCI_CSS_IDENTIFIER2 15 +#define wxSCI_CSS_ATTRIBUTE 16 + +// Lexical states for SCLEX_POV +#define wxSCI_POV_DEFAULT 0 +#define wxSCI_POV_COMMENT 1 +#define wxSCI_POV_COMMENTLINE 2 +#define wxSCI_POV_NUMBER 3 +#define wxSCI_POV_OPERATOR 4 +#define wxSCI_POV_IDENTIFIER 5 +#define wxSCI_POV_STRING 6 +#define wxSCI_POV_STRINGEOL 7 +#define wxSCI_POV_DIRECTIVE 8 +#define wxSCI_POV_BADDIRECTIVE 9 +#define wxSCI_POV_WORD2 10 +#define wxSCI_POV_WORD3 11 +#define wxSCI_POV_WORD4 12 +#define wxSCI_POV_WORD5 13 +#define wxSCI_POV_WORD6 14 +#define wxSCI_POV_WORD7 15 +#define wxSCI_POV_WORD8 16 + +// Lexical states for SCLEX_LOUT +#define wxSCI_LOUT_DEFAULT 0 +#define wxSCI_LOUT_COMMENT 1 +#define wxSCI_LOUT_NUMBER 2 +#define wxSCI_LOUT_WORD 3 +#define wxSCI_LOUT_WORD2 4 +#define wxSCI_LOUT_WORD3 5 +#define wxSCI_LOUT_WORD4 6 +#define wxSCI_LOUT_STRING 7 +#define wxSCI_LOUT_OPERATOR 8 +#define wxSCI_LOUT_IDENTIFIER 9 +#define wxSCI_LOUT_STRINGEOL 10 + +// Lexical states for SCLEX_ESCRIPT +#define wxSCI_ESCRIPT_DEFAULT 0 +#define wxSCI_ESCRIPT_COMMENT 1 +#define wxSCI_ESCRIPT_COMMENTLINE 2 +#define wxSCI_ESCRIPT_COMMENTDOC 3 +#define wxSCI_ESCRIPT_NUMBER 4 +#define wxSCI_ESCRIPT_WORD 5 +#define wxSCI_ESCRIPT_STRING 6 +#define wxSCI_ESCRIPT_OPERATOR 7 +#define wxSCI_ESCRIPT_IDENTIFIER 8 +#define wxSCI_ESCRIPT_BRACE 9 +#define wxSCI_ESCRIPT_WORD2 10 +#define wxSCI_ESCRIPT_WORD3 11 + +// Lexical states for SCLEX_PS +#define wxSCI_PS_DEFAULT 0 +#define wxSCI_PS_COMMENT 1 +#define wxSCI_PS_DSC_COMMENT 2 +#define wxSCI_PS_DSC_VALUE 3 +#define wxSCI_PS_NUMBER 4 +#define wxSCI_PS_NAME 5 +#define wxSCI_PS_KEYWORD 6 +#define wxSCI_PS_LITERAL 7 +#define wxSCI_PS_IMMEVAL 8 +#define wxSCI_PS_PAREN_ARRAY 9 +#define wxSCI_PS_PAREN_DICT 10 +#define wxSCI_PS_PAREN_PROC 11 +#define wxSCI_PS_TEXT 12 +#define wxSCI_PS_HEXSTRING 13 +#define wxSCI_PS_BASE85STRING 14 +#define wxSCI_PS_BADSTRINGCHAR 15 + +// Lexical states for SCLEX_NSIS +#define wxSCI_NSIS_DEFAULT 0 +#define wxSCI_NSIS_COMMENT 1 +#define wxSCI_NSIS_STRINGDQ 2 +#define wxSCI_NSIS_STRINGLQ 3 +#define wxSCI_NSIS_STRINGRQ 4 +#define wxSCI_NSIS_FUNCTION 5 +#define wxSCI_NSIS_VARIABLE 6 +#define wxSCI_NSIS_LABEL 7 +#define wxSCI_NSIS_USERDEFINED 8 +#define wxSCI_NSIS_SECTIONDEF 9 +#define wxSCI_NSIS_SUBSECTIONDEF 10 +#define wxSCI_NSIS_IFDEFINEDEF 11 +#define wxSCI_NSIS_MACRODEF 12 +#define wxSCI_NSIS_STRINGVAR 13 +#define wxSCI_NSIS_NUMBER 14 +#define wxSCI_NSIS_SECTIONGROUP 15 +#define wxSCI_NSIS_PAGEEX 16 +#define wxSCI_NSIS_FUNCTIONDEF 17 +#define wxSCI_NSIS_COMMENTBOX 18 + +// Lexical states for SCLEX_MMIXAL +#define wxSCI_MMIXAL_LEADWS 0 +#define wxSCI_MMIXAL_COMMENT 1 +#define wxSCI_MMIXAL_LABEL 2 +#define wxSCI_MMIXAL_OPCODE 3 +#define wxSCI_MMIXAL_OPCODE_PRE 4 +#define wxSCI_MMIXAL_OPCODE_VALID 5 +#define wxSCI_MMIXAL_OPCODE_UNKNOWN 6 +#define wxSCI_MMIXAL_OPCODE_POST 7 +#define wxSCI_MMIXAL_OPERANDS 8 +#define wxSCI_MMIXAL_NUMBER 9 +#define wxSCI_MMIXAL_REF 10 +#define wxSCI_MMIXAL_CHAR 11 +#define wxSCI_MMIXAL_STRING 12 +#define wxSCI_MMIXAL_REGISTER 13 +#define wxSCI_MMIXAL_HEX 14 +#define wxSCI_MMIXAL_OPERATOR 15 +#define wxSCI_MMIXAL_SYMBOL 16 +#define wxSCI_MMIXAL_INCLUDE 17 + +// Lexical states for SCLEX_CLW +#define wxSCI_CLW_DEFAULT 0 +#define wxSCI_CLW_LABEL 1 +#define wxSCI_CLW_COMMENT 2 +#define wxSCI_CLW_STRING 3 +#define wxSCI_CLW_USER_IDENTIFIER 4 +#define wxSCI_CLW_INTEGER_CONSTANT 5 +#define wxSCI_CLW_REAL_CONSTANT 6 +#define wxSCI_CLW_PICTURE_STRING 7 +#define wxSCI_CLW_KEYWORD 8 +#define wxSCI_CLW_COMPILER_DIRECTIVE 9 +#define wxSCI_CLW_RUNTIME_EXPRESSIONS 10 +#define wxSCI_CLW_BUILTIN_PROCEDURES_FUNCTION 11 +#define wxSCI_CLW_STRUCTURE_DATA_TYPE 12 +#define wxSCI_CLW_ATTRIBUTE 13 +#define wxSCI_CLW_STANDARD_EQUATE 14 +#define wxSCI_CLW_ERROR 15 +#define wxSCI_CLW_DEPRECATED 16 + +// Lexical states for SCLEX_LOT +#define wxSCI_LOT_DEFAULT 0 +#define wxSCI_LOT_HEADER 1 +#define wxSCI_LOT_BREAK 2 +#define wxSCI_LOT_SET 3 +#define wxSCI_LOT_PASS 4 +#define wxSCI_LOT_FAIL 5 +#define wxSCI_LOT_ABORT 6 + +// Lexical states for SCLEX_YAML +#define wxSCI_YAML_DEFAULT 0 +#define wxSCI_YAML_COMMENT 1 +#define wxSCI_YAML_IDENTIFIER 2 +#define wxSCI_YAML_KEYWORD 3 +#define wxSCI_YAML_NUMBER 4 +#define wxSCI_YAML_REFERENCE 5 +#define wxSCI_YAML_DOCUMENT 6 +#define wxSCI_YAML_TEXT 7 +#define wxSCI_YAML_ERROR 8 + +// Lexical states for SCLEX_TEX +#define wxSCI_TEX_DEFAULT 0 +#define wxSCI_TEX_SPECIAL 1 +#define wxSCI_TEX_GROUP 2 +#define wxSCI_TEX_SYMBOL 3 +#define wxSCI_TEX_COMMAND 4 +#define wxSCI_TEX_TEXT 5 +#define wxSCI_METAPOST_DEFAULT 0 +#define wxSCI_METAPOST_SPECIAL 1 +#define wxSCI_METAPOST_GROUP 2 +#define wxSCI_METAPOST_SYMBOL 3 +#define wxSCI_METAPOST_COMMAND 4 +#define wxSCI_METAPOST_TEXT 5 +#define wxSCI_METAPOST_EXTRA 6 + +// Lexical states for SCLEX_ERLANG +#define wxSCI_ERLANG_DEFAULT 0 +#define wxSCI_ERLANG_COMMENT 1 +#define wxSCI_ERLANG_VARIABLE 2 +#define wxSCI_ERLANG_NUMBER 3 +#define wxSCI_ERLANG_KEYWORD 4 +#define wxSCI_ERLANG_STRING 5 +#define wxSCI_ERLANG_OPERATOR 6 +#define wxSCI_ERLANG_ATOM 7 +#define wxSCI_ERLANG_FUNCTION_NAME 8 +#define wxSCI_ERLANG_CHARACTER 9 +#define wxSCI_ERLANG_MACRO 10 +#define wxSCI_ERLANG_RECORD 11 +#define wxSCI_ERLANG_SEPARATOR 12 +#define wxSCI_ERLANG_NODE_NAME 13 +#define wxSCI_ERLANG_UNKNOWN 31 + +// Lexical states for SCLEX_OCTAVE are identical to MatLab +// Lexical states for SCLEX_MSSQL +#define wxSCI_MSSQL_DEFAULT 0 +#define wxSCI_MSSQL_COMMENT 1 +#define wxSCI_MSSQL_LINE_COMMENT 2 +#define wxSCI_MSSQL_NUMBER 3 +#define wxSCI_MSSQL_STRING 4 +#define wxSCI_MSSQL_OPERATOR 5 +#define wxSCI_MSSQL_IDENTIFIER 6 +#define wxSCI_MSSQL_VARIABLE 7 +#define wxSCI_MSSQL_COLUMN_NAME 8 +#define wxSCI_MSSQL_STATEMENT 9 +#define wxSCI_MSSQL_DATATYPE 10 +#define wxSCI_MSSQL_SYSTABLE 11 +#define wxSCI_MSSQL_GLOBAL_VARIABLE 12 +#define wxSCI_MSSQL_FUNCTION 13 +#define wxSCI_MSSQL_STORED_PROCEDURE 14 +#define wxSCI_MSSQL_DEFAULT_PREF_DATATYPE 15 +#define wxSCI_MSSQL_COLUMN_NAME_2 16 + +// Lexical states for SCLEX_VERILOG +#define wxSCI_V_DEFAULT 0 +#define wxSCI_V_COMMENT 1 +#define wxSCI_V_COMMENTLINE 2 +#define wxSCI_V_COMMENTLINEBANG 3 +#define wxSCI_V_NUMBER 4 +#define wxSCI_V_WORD 5 +#define wxSCI_V_STRING 6 +#define wxSCI_V_WORD2 7 +#define wxSCI_V_WORD3 8 +#define wxSCI_V_PREPROCESSOR 9 +#define wxSCI_V_OPERATOR 10 +#define wxSCI_V_IDENTIFIER 11 +#define wxSCI_V_STRINGEOL 12 +#define wxSCI_V_USER 19 + +// Lexical states for SCLEX_KIX +#define wxSCI_KIX_DEFAULT 0 +#define wxSCI_KIX_COMMENT 1 +#define wxSCI_KIX_STRING1 2 +#define wxSCI_KIX_STRING2 3 +#define wxSCI_KIX_NUMBER 4 +#define wxSCI_KIX_VAR 5 +#define wxSCI_KIX_MACRO 6 +#define wxSCI_KIX_KEYWORD 7 +#define wxSCI_KIX_FUNCTIONS 8 +#define wxSCI_KIX_OPERATOR 9 +#define wxSCI_KIX_IDENTIFIER 31 + +// Lexical states for SCLEX_GUI4CLI +#define wxSCI_GC_DEFAULT 0 +#define wxSCI_GC_COMMENTLINE 1 +#define wxSCI_GC_COMMENTBLOCK 2 +#define wxSCI_GC_GLOBAL 3 +#define wxSCI_GC_EVENT 4 +#define wxSCI_GC_ATTRIBUTE 5 +#define wxSCI_GC_CONTROL 6 +#define wxSCI_GC_COMMAND 7 +#define wxSCI_GC_STRING 8 +#define wxSCI_GC_OPERATOR 9 + +// Lexical states for SCLEX_SPECMAN +#define wxSCI_SN_DEFAULT 0 +#define wxSCI_SN_CODE 1 +#define wxSCI_SN_COMMENTLINE 2 +#define wxSCI_SN_COMMENTLINEBANG 3 +#define wxSCI_SN_NUMBER 4 +#define wxSCI_SN_WORD 5 +#define wxSCI_SN_STRING 6 +#define wxSCI_SN_WORD2 7 +#define wxSCI_SN_WORD3 8 +#define wxSCI_SN_PREPROCESSOR 9 +#define wxSCI_SN_OPERATOR 10 +#define wxSCI_SN_IDENTIFIER 11 +#define wxSCI_SN_STRINGEOL 12 +#define wxSCI_SN_REGEXTAG 13 +#define wxSCI_SN_SIGNAL 14 +#define wxSCI_SN_USER 19 + +// Lexical states for SCLEX_AU3 +#define wxSCI_AU3_DEFAULT 0 +#define wxSCI_AU3_COMMENT 1 +#define wxSCI_AU3_COMMENTBLOCK 2 +#define wxSCI_AU3_NUMBER 3 +#define wxSCI_AU3_FUNCTION 4 +#define wxSCI_AU3_KEYWORD 5 +#define wxSCI_AU3_MACRO 6 +#define wxSCI_AU3_STRING 7 +#define wxSCI_AU3_OPERATOR 8 +#define wxSCI_AU3_VARIABLE 9 +#define wxSCI_AU3_SENT 10 +#define wxSCI_AU3_PREPROCESSOR 11 +#define wxSCI_AU3_SPECIAL 12 +#define wxSCI_AU3_EXPAND 13 +#define wxSCI_AU3_COMOBJ 14 +#define wxSCI_AU3_UDF 15 + +// Lexical states for SCLEX_APDL +#define wxSCI_APDL_DEFAULT 0 +#define wxSCI_APDL_COMMENT 1 +#define wxSCI_APDL_COMMENTBLOCK 2 +#define wxSCI_APDL_NUMBER 3 +#define wxSCI_APDL_STRING 4 +#define wxSCI_APDL_OPERATOR 5 +#define wxSCI_APDL_WORD 6 +#define wxSCI_APDL_PROCESSOR 7 +#define wxSCI_APDL_COMMAND 8 +#define wxSCI_APDL_SLASHCOMMAND 9 +#define wxSCI_APDL_STARCOMMAND 10 +#define wxSCI_APDL_ARGUMENT 11 +#define wxSCI_APDL_FUNCTION 12 + +// Lexical states for SCLEX_BASH +#define wxSCI_SH_DEFAULT 0 +#define wxSCI_SH_ERROR 1 +#define wxSCI_SH_COMMENTLINE 2 +#define wxSCI_SH_NUMBER 3 +#define wxSCI_SH_WORD 4 +#define wxSCI_SH_STRING 5 +#define wxSCI_SH_CHARACTER 6 +#define wxSCI_SH_OPERATOR 7 +#define wxSCI_SH_IDENTIFIER 8 +#define wxSCI_SH_SCALAR 9 +#define wxSCI_SH_PARAM 10 +#define wxSCI_SH_BACKTICKS 11 +#define wxSCI_SH_HERE_DELIM 12 +#define wxSCI_SH_HERE_Q 13 + +// Lexical states for SCLEX_ASN1 +#define wxSCI_ASN1_DEFAULT 0 +#define wxSCI_ASN1_COMMENT 1 +#define wxSCI_ASN1_IDENTIFIER 2 +#define wxSCI_ASN1_STRING 3 +#define wxSCI_ASN1_OID 4 +#define wxSCI_ASN1_SCALAR 5 +#define wxSCI_ASN1_KEYWORD 6 +#define wxSCI_ASN1_ATTRIBUTE 7 +#define wxSCI_ASN1_DESCRIPTOR 8 +#define wxSCI_ASN1_TYPE 9 +#define wxSCI_ASN1_OPERATOR 10 + +// Lexical states for SCLEX_VHDL +#define wxSCI_VHDL_DEFAULT 0 +#define wxSCI_VHDL_COMMENT 1 +#define wxSCI_VHDL_COMMENTLINEBANG 2 +#define wxSCI_VHDL_NUMBER 3 +#define wxSCI_VHDL_STRING 4 +#define wxSCI_VHDL_OPERATOR 5 +#define wxSCI_VHDL_IDENTIFIER 6 +#define wxSCI_VHDL_STRINGEOL 7 +#define wxSCI_VHDL_KEYWORD 8 +#define wxSCI_VHDL_STDOPERATOR 9 +#define wxSCI_VHDL_ATTRIBUTE 10 +#define wxSCI_VHDL_STDFUNCTION 11 +#define wxSCI_VHDL_STDPACKAGE 12 +#define wxSCI_VHDL_STDTYPE 13 +#define wxSCI_VHDL_USERWORD 14 + +// Lexical states for SCLEX_CAML +#define wxSCI_CAML_DEFAULT 0 +#define wxSCI_CAML_IDENTIFIER 1 +#define wxSCI_CAML_TAGNAME 2 +#define wxSCI_CAML_KEYWORD 3 +#define wxSCI_CAML_KEYWORD2 4 +#define wxSCI_CAML_KEYWORD3 5 +#define wxSCI_CAML_LINENUM 6 +#define wxSCI_CAML_OPERATOR 7 +#define wxSCI_CAML_NUMBER 8 +#define wxSCI_CAML_CHAR 9 +#define wxSCI_CAML_STRING 11 +#define wxSCI_CAML_COMMENT 12 +#define wxSCI_CAML_COMMENT1 13 +#define wxSCI_CAML_COMMENT2 14 +#define wxSCI_CAML_COMMENT3 15 + +// Lexical states for SCLEX_HA +#define wxSCI_HA_DEFAULT 0 +#define wxSCI_HA_IDENTIFIER 1 +#define wxSCI_HA_KEYWORD 2 +#define wxSCI_HA_NUMBER 3 +#define wxSCI_HA_STRING 4 +#define wxSCI_HA_CHARACTER 5 +#define wxSCI_HA_CLASS 6 +#define wxSCI_HA_MODULE 7 +#define wxSCI_HA_CAPITAL 8 +#define wxSCI_HA_DATA 9 +#define wxSCI_HA_IMPORT 10 +#define wxSCI_HA_OPERATOR 11 +#define wxSCI_HA_INSTANCE 12 +#define wxSCI_HA_COMMENTLINE 13 +#define wxSCI_HA_COMMENTBLOCK 14 +#define wxSCI_HA_COMMENTBLOCK2 15 +#define wxSCI_HA_COMMENTBLOCK3 16 + +// Lexical states for SCLEX_T3 +#define wxSCI_T3_DEFAULT 0 +#define wxSCI_T3_X_DEFAULT 1 +#define wxSCI_T3_PREPROCESSOR 2 +#define wxSCI_T3_BLOCK_COMMENT 3 +#define wxSCI_T3_LINE_COMMENT 4 +#define wxSCI_T3_OPERATOR 5 +#define wxSCI_T3_KEYWORD 6 +#define wxSCI_T3_NUMBER 7 +#define wxSCI_T3_IDENTIFIER 8 +#define wxSCI_T3_S_STRING 9 +#define wxSCI_T3_D_STRING 10 +#define wxSCI_T3_X_STRING 11 +#define wxSCI_T3_LIB_DIRECTIVE 12 +#define wxSCI_T3_MSG_PARAM 13 +#define wxSCI_T3_HTML_TAG 14 +#define wxSCI_T3_HTML_DEFAULT 15 +#define wxSCI_T3_HTML_STRING 16 +#define wxSCI_T3_USER1 17 +#define wxSCI_T3_USER2 18 +#define wxSCI_T3_USER3 19 + +// Lexical states for SCLEX_REBOL +#define wxSCI_REBOL_DEFAULT 0 +#define wxSCI_REBOL_COMMENTLINE 1 +#define wxSCI_REBOL_COMMENTBLOCK 2 +#define wxSCI_REBOL_PREFACE 3 +#define wxSCI_REBOL_OPERATOR 4 +#define wxSCI_REBOL_CHARACTER 5 +#define wxSCI_REBOL_QUOTEDSTRING 6 +#define wxSCI_REBOL_BRACEDSTRING 7 +#define wxSCI_REBOL_NUMBER 8 +#define wxSCI_REBOL_PAIR 9 +#define wxSCI_REBOL_TUPLE 10 +#define wxSCI_REBOL_BINARY 11 +#define wxSCI_REBOL_MONEY 12 +#define wxSCI_REBOL_ISSUE 13 +#define wxSCI_REBOL_TAG 14 +#define wxSCI_REBOL_FILE 15 +#define wxSCI_REBOL_EMAIL 16 +#define wxSCI_REBOL_URL 17 +#define wxSCI_REBOL_DATE 18 +#define wxSCI_REBOL_TIME 19 +#define wxSCI_REBOL_IDENTIFIER 20 +#define wxSCI_REBOL_WORD 21 +#define wxSCI_REBOL_WORD2 22 +#define wxSCI_REBOL_WORD3 23 +#define wxSCI_REBOL_WORD4 24 +#define wxSCI_REBOL_WORD5 25 +#define wxSCI_REBOL_WORD6 26 +#define wxSCI_REBOL_WORD7 27 +#define wxSCI_REBOL_WORD8 28 + +// Lexical states for SCLEX_SQL +#define wxSCI_SQL_DEFAULT 0 +#define wxSCI_SQL_COMMENT 1 +#define wxSCI_SQL_COMMENTLINE 2 +#define wxSCI_SQL_COMMENTDOC 3 +#define wxSCI_SQL_NUMBER 4 +#define wxSCI_SQL_WORD 5 +#define wxSCI_SQL_STRING 6 +#define wxSCI_SQL_CHARACTER 7 +#define wxSCI_SQL_SQLPLUS 8 +#define wxSCI_SQL_SQLPLUS_PROMPT 9 +#define wxSCI_SQL_OPERATOR 10 +#define wxSCI_SQL_IDENTIFIER 11 +#define wxSCI_SQL_SQLPLUS_COMMENT 13 +#define wxSCI_SQL_COMMENTLINEDOC 15 +#define wxSCI_SQL_WORD2 16 +#define wxSCI_SQL_COMMENTDOCKEYWORD 17 +#define wxSCI_SQL_COMMENTDOCKEYWORDERROR 18 +#define wxSCI_SQL_USER1 19 +#define wxSCI_SQL_USER2 20 +#define wxSCI_SQL_USER3 21 +#define wxSCI_SQL_USER4 22 +#define wxSCI_SQL_QUOTEDIDENTIFIER 23 + +// Lexical states for SCLEX_ST +#define wxSCI_ST_DEFAULT 0 +#define wxSCI_ST_STRING 1 +#define wxSCI_ST_NUMBER 2 +#define wxSCI_ST_COMMENT 3 +#define wxSCI_ST_SYMBOL 4 +#define wxSCI_ST_BINARY 5 +#define wxSCI_ST_BOOL 6 +#define wxSCI_ST_SELF 7 +#define wxSCI_ST_SUPER 8 +#define wxSCI_ST_NIL 9 +#define wxSCI_ST_GLOBAL 10 +#define wxSCI_ST_RETURN 11 +#define wxSCI_ST_SPECIAL 12 +#define wxSCI_ST_KWSEND 13 +#define wxSCI_ST_ASSIGN 14 +#define wxSCI_ST_CHARACTER 15 +#define wxSCI_ST_SPEC_SEL 16 + +// Lexical states for SCLEX_FS +#define wxSCI_FS_DEFAULT 0 +#define wxSCI_FS_COMMENT 1 +#define wxSCI_FS_COMMENTLINE 2 +#define wxSCI_FS_COMMENTDOC 3 +#define wxSCI_FS_COMMENTLINEDOC 4 +#define wxSCI_FS_COMMENTDOCKEYWORD 5 +#define wxSCI_FS_COMMENTDOCKEYWORDERROR 6 +#define wxSCI_FS_KEYWORD 7 +#define wxSCI_FS_KEYWORD2 8 +#define wxSCI_FS_KEYWORD3 9 +#define wxSCI_FS_KEYWORD4 10 +#define wxSCI_FS_NUMBER 11 +#define wxSCI_FS_STRING 12 +#define wxSCI_FS_PREPROCESSOR 13 +#define wxSCI_FS_OPERATOR 14 +#define wxSCI_FS_IDENTIFIER 15 +#define wxSCI_FS_DATE 16 +#define wxSCI_FS_STRINGEOL 17 +#define wxSCI_FS_CONSTANT 18 +#define wxSCI_FS_WORDOPERATOR 19 +#define wxSCI_FS_DISABLEDCODE 20 +#define wxSCI_FS_DEFAULT_C 21 +#define wxSCI_FS_COMMENTDOC_C 22 +#define wxSCI_FS_COMMENTLINEDOC_C 23 +#define wxSCI_FS_KEYWORD_C 24 +#define wxSCI_FS_KEYWORD2_C 25 +#define wxSCI_FS_NUMBER_C 26 +#define wxSCI_FS_STRING_C 27 +#define wxSCI_FS_PREPROCESSOR_C 28 +#define wxSCI_FS_OPERATOR_C 29 +#define wxSCI_FS_IDENTIFIER_C 30 +#define wxSCI_FS_STRINGEOL_C 31 + +// Lexical states for SCLEX_CSOUND +#define wxSCI_CSOUND_DEFAULT 0 +#define wxSCI_CSOUND_COMMENT 1 +#define wxSCI_CSOUND_NUMBER 2 +#define wxSCI_CSOUND_OPERATOR 3 +#define wxSCI_CSOUND_INSTR 4 +#define wxSCI_CSOUND_IDENTIFIER 5 +#define wxSCI_CSOUND_OPCODE 6 +#define wxSCI_CSOUND_HEADERSTMT 7 +#define wxSCI_CSOUND_USERKEYWORD 8 +#define wxSCI_CSOUND_COMMENTBLOCK 9 +#define wxSCI_CSOUND_PARAM 10 +#define wxSCI_CSOUND_ARATE_VAR 11 +#define wxSCI_CSOUND_KRATE_VAR 12 +#define wxSCI_CSOUND_IRATE_VAR 13 +#define wxSCI_CSOUND_GLOBAL_VAR 14 +#define wxSCI_CSOUND_STRINGEOL 15 + +// Lexical states for SCLEX_INNOSETUP +#define wxSCI_INNO_DEFAULT 0 +#define wxSCI_INNO_COMMENT 1 +#define wxSCI_INNO_KEYWORD 2 +#define wxSCI_INNO_PARAMETER 3 +#define wxSCI_INNO_SECTION 4 +#define wxSCI_INNO_PREPROC 5 +#define wxSCI_INNO_PREPROC_INLINE 6 +#define wxSCI_INNO_COMMENT_PASCAL 7 +#define wxSCI_INNO_KEYWORD_PASCAL 8 +#define wxSCI_INNO_KEYWORD_USER 9 +#define wxSCI_INNO_STRING_DOUBLE 10 +#define wxSCI_INNO_STRING_SINGLE 11 +#define wxSCI_INNO_IDENTIFIER 12 + +// Lexical states for SCLEX_OPAL +#define wxSCI_OPAL_SPACE 0 +#define wxSCI_OPAL_COMMENT_BLOCK 1 +#define wxSCI_OPAL_COMMENT_LINE 2 +#define wxSCI_OPAL_INTEGER 3 +#define wxSCI_OPAL_KEYWORD 4 +#define wxSCI_OPAL_SORT 5 +#define wxSCI_OPAL_STRING 6 +#define wxSCI_OPAL_PAR 7 +#define wxSCI_OPAL_BOOL_CONST 8 +#define wxSCI_OPAL_DEFAULT 32 + +// Lexical states for SCLEX_SPICE +#define wxSCI_SPICE_DEFAULT 0 +#define wxSCI_SPICE_IDENTIFIER 1 +#define wxSCI_SPICE_KEYWORD 2 +#define wxSCI_SPICE_KEYWORD2 3 +#define wxSCI_SPICE_KEYWORD3 4 +#define wxSCI_SPICE_NUMBER 5 +#define wxSCI_SPICE_DELIMITER 6 +#define wxSCI_SPICE_VALUE 7 +#define wxSCI_SPICE_COMMENTLINE 8 + + +//----------------------------------------- +// Commands that can be bound to keystrokes + + +// Redoes the next action on the undo history. +#define wxSCI_CMD_REDO 2011 + +// Select all the text in the document. +#define wxSCI_CMD_SELECTALL 2013 + +// Undo one action in the undo history. +#define wxSCI_CMD_UNDO 2176 + +// Cut the selection to the clipboard. +#define wxSCI_CMD_CUT 2177 + +// Copy the selection to the clipboard. +#define wxSCI_CMD_COPY 2178 + +// Paste the contents of the clipboard into the document replacing the selection. +#define wxSCI_CMD_PASTE 2179 + +// Clear the selection. +#define wxSCI_CMD_CLEAR 2180 + +// Move caret down one line. +#define wxSCI_CMD_LINEDOWN 2300 + +// Move caret down one line extending selection to new caret position. +#define wxSCI_CMD_LINEDOWNEXTEND 2301 + +// Move caret up one line. +#define wxSCI_CMD_LINEUP 2302 + +// Move caret up one line extending selection to new caret position. +#define wxSCI_CMD_LINEUPEXTEND 2303 + +// Move caret left one character. +#define wxSCI_CMD_CHARLEFT 2304 + +// Move caret left one character extending selection to new caret position. +#define wxSCI_CMD_CHARLEFTEXTEND 2305 + +// Move caret right one character. +#define wxSCI_CMD_CHARRIGHT 2306 + +// Move caret right one character extending selection to new caret position. +#define wxSCI_CMD_CHARRIGHTEXTEND 2307 + +// Move caret left one word. +#define wxSCI_CMD_WORDLEFT 2308 + +// Move caret left one word extending selection to new caret position. +#define wxSCI_CMD_WORDLEFTEXTEND 2309 + +// Move caret right one word. +#define wxSCI_CMD_WORDRIGHT 2310 + +// Move caret right one word extending selection to new caret position. +#define wxSCI_CMD_WORDRIGHTEXTEND 2311 + +// Move caret to first position on line. +#define wxSCI_CMD_HOME 2312 + +// Move caret to first position on line extending selection to new caret position. +#define wxSCI_CMD_HOMEEXTEND 2313 + +// Move caret to last position on line. +#define wxSCI_CMD_LINEEND 2314 + +// Move caret to last position on line extending selection to new caret position. +#define wxSCI_CMD_LINEENDEXTEND 2315 + +// Move caret to first position in document. +#define wxSCI_CMD_DOCUMENTSTART 2316 + +// Move caret to first position in document extending selection to new caret position. +#define wxSCI_CMD_DOCUMENTSTARTEXTEND 2317 + +// Move caret to last position in document. +#define wxSCI_CMD_DOCUMENTEND 2318 + +// Move caret to last position in document extending selection to new caret position. +#define wxSCI_CMD_DOCUMENTENDEXTEND 2319 + +// Move caret one page up. +#define wxSCI_CMD_PAGEUP 2320 + +// Move caret one page up extending selection to new caret position. +#define wxSCI_CMD_PAGEUPEXTEND 2321 + +// Move caret one page down. +#define wxSCI_CMD_PAGEDOWN 2322 + +// Move caret one page down extending selection to new caret position. +#define wxSCI_CMD_PAGEDOWNEXTEND 2323 + +// Switch from insert to overtype mode or the reverse. +#define wxSCI_CMD_EDITTOGGLEOVERTYPE 2324 + +// Cancel any modes such as call tip or auto-completion list display. +#define wxSCI_CMD_CANCEL 2325 + +// Delete the selection or if no selection, the character before the caret. +#define wxSCI_CMD_DELETEBACK 2326 + +// If selection is empty or all on one line replace the selection with a tab character. +// If more than one line selected, indent the lines. +#define wxSCI_CMD_TAB 2327 + +// Dedent the selected lines. +#define wxSCI_CMD_BACKTAB 2328 + +// Insert a new line, may use a CRLF, CR or LF depending on EOL mode. +#define wxSCI_CMD_NEWLINE 2329 + +// Insert a Form Feed character. +#define wxSCI_CMD_FORMFEED 2330 + +// Move caret to before first visible character on line. +// If already there move to first character on line. +#define wxSCI_CMD_VCHOME 2331 + +// Like VCHome but extending selection to new caret position. +#define wxSCI_CMD_VCHOMEEXTEND 2332 + +// Magnify the displayed text by increasing the sizes by 1 point. +#define wxSCI_CMD_ZOOMIN 2333 + +// Make the displayed text smaller by decreasing the sizes by 1 point. +#define wxSCI_CMD_ZOOMOUT 2334 + +// Delete the word to the left of the caret. +#define wxSCI_CMD_DELWORDLEFT 2335 + +// Delete the word to the right of the caret. +#define wxSCI_CMD_DELWORDRIGHT 2336 + +// Cut the line containing the caret. +#define wxSCI_CMD_LINECUT 2337 + +// Delete the line containing the caret. +#define wxSCI_CMD_LINEDELETE 2338 + +// Switch the current line with the previous. +#define wxSCI_CMD_LINETRANSPOSE 2339 + +// Duplicate the current line. +#define wxSCI_CMD_LINEDUPLICATE 2404 + +// Transform the selection to lower case. +#define wxSCI_CMD_LOWERCASE 2340 + +// Transform the selection to upper case. +#define wxSCI_CMD_UPPERCASE 2341 + +// Scroll the document down, keeping the caret visible. +#define wxSCI_CMD_LINESCROLLDOWN 2342 + +// Scroll the document up, keeping the caret visible. +#define wxSCI_CMD_LINESCROLLUP 2343 + +// Delete the selection or if no selection, the character before the caret. +// Will not delete the character before at the start of a line. +#define wxSCI_CMD_DELETEBACKNOTLINE 2344 + +// Move caret to first position on display line. +#define wxSCI_CMD_HOMEDISPLAY 2345 + +// Move caret to first position on display line extending selection to +// new caret position. +#define wxSCI_CMD_HOMEDISPLAYEXTEND 2346 + +// Move caret to last position on display line. +#define wxSCI_CMD_LINEENDDISPLAY 2347 + +// Move caret to last position on display line extending selection to new +// caret position. +#define wxSCI_CMD_LINEENDDISPLAYEXTEND 2348 + +// These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)? +// except they behave differently when word-wrap is enabled: +// They go first to the start / end of the display line, like (Home|LineEnd)Display +// The difference is that, the cursor is already at the point, it goes on to the start +// or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?. +#define wxSCI_CMD_HOMEWRAP 2349 +#define wxSCI_CMD_HOMEWRAPEXTEND 2450 +#define wxSCI_CMD_LINEENDWRAP 2451 +#define wxSCI_CMD_LINEENDWRAPEXTEND 2452 +#define wxSCI_CMD_VCHOMEWRAP 2453 +#define wxSCI_CMD_VCHOMEWRAPEXTEND 2454 + +// Copy the line containing the caret. +#define wxSCI_CMD_LINECOPY 2455 + +// Move to the previous change in capitalisation. +#define wxSCI_CMD_WORDPARTLEFT 2390 + +// Move to the previous change in capitalisation extending selection +// to new caret position. +#define wxSCI_CMD_WORDPARTLEFTEXTEND 2391 + +// Move to the change next in capitalisation. +#define wxSCI_CMD_WORDPARTRIGHT 2392 + +// Move to the next change in capitalisation extending selection +// to new caret position. +#define wxSCI_CMD_WORDPARTRIGHTEXTEND 2393 + +// Delete back from the current position to the start of the line. +#define wxSCI_CMD_DELLINELEFT 2395 + +// Delete forwards from the current position to the end of the line. +#define wxSCI_CMD_DELLINERIGHT 2396 + +// Move caret between paragraphs (delimited by empty lines). +#define wxSCI_CMD_PARADOWN 2413 +#define wxSCI_CMD_PARADOWNEXTEND 2414 +#define wxSCI_CMD_PARAUP 2415 +#define wxSCI_CMD_PARAUPEXTEND 2416 + +// Move caret down one line, extending rectangular selection to new caret position. +#define wxSCI_CMD_LINEDOWNRECTEXTEND 2426 + +// Move caret up one line, extending rectangular selection to new caret position. +#define wxSCI_CMD_LINEUPRECTEXTEND 2427 + +// Move caret left one character, extending rectangular selection to new caret position. +#define wxSCI_CMD_CHARLEFTRECTEXTEND 2428 + +// Move caret right one character, extending rectangular selection to new caret position. +#define wxSCI_CMD_CHARRIGHTRECTEXTEND 2429 + +// Move caret to first position on line, extending rectangular selection to new caret position. +#define wxSCI_CMD_HOMERECTEXTEND 2430 + +// Move caret to before first visible character on line. +// If already there move to first character on line. +// In either case, extend rectangular selection to new caret position. +#define wxSCI_CMD_VCHOMERECTEXTEND 2431 + +// Move caret to last position on line, extending rectangular selection to new caret position. +#define wxSCI_CMD_LINEENDRECTEXTEND 2432 + +// Move caret one page up, extending rectangular selection to new caret position. +#define wxSCI_CMD_PAGEUPRECTEXTEND 2433 + +// Move caret one page down, extending rectangular selection to new caret position. +#define wxSCI_CMD_PAGEDOWNRECTEXTEND 2434 + +// Move caret to top of page, or one page up if already at top of page. +#define wxSCI_CMD_STUTTEREDPAGEUP 2435 + +// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position. +#define wxSCI_CMD_STUTTEREDPAGEUPEXTEND 2436 + +// Move caret to bottom of page, or one page down if already at bottom of page. +#define wxSCI_CMD_STUTTEREDPAGEDOWN 2437 + +// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position. +#define wxSCI_CMD_STUTTEREDPAGEDOWNEXTEND 2438 + +// Move caret left one word, position cursor at end of word. +#define wxSCI_CMD_WORDLEFTEND 2439 + +// Move caret left one word, position cursor at end of word, extending selection to new caret position. +#define wxSCI_CMD_WORDLEFTENDEXTEND 2440 + +// Move caret right one word, position cursor at end of word. +#define wxSCI_CMD_WORDRIGHTEND 2441 + +// Move caret right one word, position cursor at end of word, extending selection to new caret position. +#define wxSCI_CMD_WORDRIGHTENDEXTEND 2442 + + +// END of generated section +//---------------------------------------------------------------------- + +class ScintillaWX; // forward declare +class WordList; + +#ifdef SCI_NAMESPACE // begin [CHANGED] + #ifndef SCI_SCOPE + #define SCI_SCOPE( x ) Scintilla::x + #endif + namespace Scintilla{ +#else + #ifndef SCI_SCOPE + #define SCI_SCOPE( x ) x + #endif +#endif + +struct SCNotification; +#ifdef SCI_NAMESPACE +} +#endif // end [CHANGED] + +#ifndef SWIG +extern const wxChar* wxSCINameStr; +class WXDLLIMPEXP_SCI wxScintilla; +class WXDLLIMPEXP_SCI wxScintillaEvent; +#endif + +//---------------------------------------------------------------------- + +class WXDLLIMPEXP_SCI wxScintilla : public wxControl { +public: + +#ifdef SWIGPYTHON + %pythonAppend wxScintilla "self._setOORInfo(self)" + %pythonAppend wxScintilla() "" + + wxScintilla (wxWindow *parent, wxWindowID id=wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxString& name = wxSCINameStr); + %name(PreScintilla) wxScintilla(); + +#elif defined (SWIGRUBY) + wxScintilla (wxWindow *parent, wxWindowID id=wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxString& name = wxSCINameStr); + ~wxScintilla(); +#else + wxScintilla (wxWindow *parent, wxWindowID id=wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxString& name = wxSCINameStr); + wxScintilla() { m_swx = NULL; } + ~wxScintilla(); + +#endif + + bool Create (wxWindow *parent, wxWindowID id=wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxString& name = wxSCINameStr); + + +//---------------------------------------------------------------------- +// BEGIN generated section. The following code is automatically generated +// by gen_iface.py. Do not edit this file. Edit wxscintilla.h.in instead +// and regenerate + + + // Add text to the document. + void AddText (const wxString& text); + void AddText (const int length, const wxString& text); + + // Add array of cells to document. + void AddStyledText (const wxMemoryBuffer& data); + + // Insert string at a position. + void InsertText (int pos, const wxString& text); + + // Delete all text in the document. + void ClearAll(); + + // Set all style bytes to 0, remove all folding information. + void ClearDocumentStyle(); + + // The number of characters in the document. + int GetLength(); + + // Returns the character byte at the position. + int GetCharAt (int pos); + + // Returns the position of the caret. + int GetCurrentPos(); + + // Returns the position of the opposite end of the selection to the caret. + int GetAnchor(); + + // Returns the style byte at the position. + int GetStyleAt (int pos); + + // Redoes the next action on the undo history. + void Redo(); + + // Choose between collecting actions into the undo + // history and discarding them. + void SetUndoCollection (bool collectUndo); + + // Select all the text in the document. + void SelectAll(); + + // Remember the current position in the undo history as the position + // at which the document was saved. + void SetSavePoint(); + + // Retrieve a buffer of cells. + wxMemoryBuffer GetStyledText (int startPos, int endPos); + + // Are there any redoable actions in the undo history? + bool CanRedo(); + + // Retrieve the line number at which a particular marker is located. + int MarkerLineFromHandle (int handle); + + // Delete a marker. + void MarkerDeleteHandle (int handle); + + // Is undo history being collected? + bool GetUndoCollection(); + + // Are white space characters currently visible? + // Returns one of SCWS_* constants. + int GetViewWhiteSpace(); + + // Make white space characters invisible, always visible or visible outside indentation. + void SetViewWhiteSpace (int viewWS); + + // Find the position from a point within the window. + int PositionFromPoint (wxPoint pt); + + // Find the position from a point within the window but return + // INVALID_POSITION if not close to text. + int PositionFromPointClose (int x, int y); + + // Set caret to start of a line and ensure it is visible. + void GotoLine (int line); + + // Set caret to a position and ensure it is visible. + void GotoPos (int pos); + + // Set the selection anchor to a position. The anchor is the opposite + // end of the selection from the caret. + void SetAnchor (int posAnchor); + + // Retrieve the text of the line containing the caret. + // Returns the index of the caret on the line. +#ifdef SWIG + wxString GetCurLine (int* OUTPUT); +#else + wxString GetCurLine (int* linePos = NULL); +#endif + + // Retrieve the position of the last correctly styled character. + int GetEndStyled(); + + // Convert all line endings in the document to one mode. + void ConvertEOLs (int eolMode); + + // Retrieve the current end of line mode - one of CRLF, CR, or LF. + int GetEOLMode(); + + // Set the current end of line mode. + void SetEOLMode (int eolMode); + + // Set the current styling position to pos and the styling mask to mask. + // The styling mask can be used to protect some bits in each styling byte from modification. + void StartStyling (int pos, int mask); + + // Change style from current styling position for length characters to a style + // and move the current styling position to after this newly styled segment. + void SetStyling (int length, int style); + + // Is drawing done first into a buffer or direct to the screen? + bool GetBufferedDraw(); + + // If drawing is buffered then each line of text is drawn into a bitmap buffer + // before drawing it to the screen to avoid flicker. + void SetBufferedDraw (bool buffered); + + // Change the visible size of a tab to be a multiple of the width of a space character. + void SetTabWidth (int tabWidth); + + // Retrieve the visible size of a tab. + int GetTabWidth(); + + // Set the code page used to interpret the bytes of the document as characters. + void SetCodePage (int codePage); + + // Set the symbol used for a particular marker number, + void MarkerDefine (int markerNumber, int markerSymbol); + + // Set the foreground colour used for a particular marker number. + void MarkerSetForeground (int markerNumber, const wxColour& fore); + + // Set the background colour used for a particular marker number. + void MarkerSetBackground (int markerNumber, const wxColour& back); + + // Add a marker to a line, returning an ID which can be used to find or delete the marker. + int MarkerAdd (int line, int markerNumber); + + // Delete a marker from a line. + void MarkerDelete (int line, int markerNumber); + + // Delete a marker with a particular number from all lines. + void MarkerDeleteAll (int markerNumber); + + // Get a bit mask of all the markers set on a line. + int MarkerGet (int line); + + // Find the next line after lineStart that includes a marker in mask. + int MarkerNext (int lineStart, int markerMask); + + // Find the previous line before lineStart that includes a marker in mask. + int MarkerPrevious (int lineStart, int markerMask); + + // Define a marker from a bitmap + void MarkerDefineBitmap (int markerNumber, const wxBitmap& bmp); + + // Add a set of markers to a line. + void MarkerAddSet (int line, int markerSet); + + // Set the alpha used for a marker that is drawn in the text area, not the margin. + void MarkerSetAlpha (int markerNumber, int alpha); + + // Set a margin to be either numeric or symbolic. + void SetMarginType (int margin, int marginType); + + // Retrieve the type of a margin. + int GetMarginType (int margin); + + // Set the width of a margin to a width expressed in pixels. + void SetMarginWidth (int margin, int pixels); + + // Retrieve the width of a margin in pixels. + int GetMarginWidth (int margin); + + // Set a mask that determines which markers are displayed in a margin. + void SetMarginMask (int margin, int mask); + + // Retrieve the marker mask of a margin. + int GetMarginMask (int margin); + + // Make a margin sensitive or insensitive to mouse clicks. + void SetMarginSensitive (int margin, bool sensitive); + + // Retrieve the mouse click sensitivity of a margin. + bool GetMarginSensitive (int margin); + + // Clear all the styles and make equivalent to the global default style. + void StyleClearAll(); + + // Set the foreground colour of a style. + void StyleSetForeground (int style, const wxColour& fore); + + // Get the background colour of a style + wxColour StyleGetBackground(int style); + + // Get the foreground colour of a style + wxColour StyleGetForeground(int style); + + // Set the background colour of a style. + void StyleSetBackground (int style, const wxColour& back); + + // Set a style to be bold or not. + void StyleSetBold (int style, bool bold); + + // Set a style to be italic or not. + void StyleSetItalic (int style, bool italic); + + // Set the size of characters of a style. + void StyleSetSize (int style, int sizePoints); + + // Set the font of a style. + void StyleSetFaceName (int style, const wxString& fontName); + + // Set a style to have its end of line filled or not. + void StyleSetEOLFilled (int style, bool filled); + + // Reset the default style to its state at startup + void StyleResetDefault(); + + // Set a style to be underlined or not. + void StyleSetUnderline (int style, bool underline); + + // Set a style to be mixed case, or to force upper or lower case. + void StyleSetCase (int style, int caseMode); + + // Set a style to be a hotspot or not. + void StyleSetHotSpot (int style, bool hotspot); + + // Get the alpha of the selection. + int GetSelAlpha (); + + // Set the alpha of the selection. + void SetSelAlpha (int alpha); + + // Set the foreground colour of the selection and whether to use this setting. + void SetSelForeground (bool useSetting, const wxColour& fore); + + // Set the background colour of the selection and whether to use this setting. + void SetSelBackground (bool useSetting, const wxColour& back); + + // Set the foreground colour of the caret. + void SetCaretForeground (const wxColour& fore); + + // When key+modifier combination km is pressed perform msg. + void CmdKeyAssign (int key, int modifiers, int cmd); + + // When key+modifier combination km is pressed do nothing. + void CmdKeyClear (int key, int modifiers); + + // Drop all key mappings. + void CmdKeyClearAll(); + + // Set the styles for a segment of the document. + void SetStyleBytes (int length, char* styleBytes); + + // Set a style to be visible or not. + void StyleSetVisible (int style, bool visible); + + // Get the time in milliseconds that the caret is on and off. + int GetCaretPeriod(); + + // Get the time in milliseconds that the caret is on and off. 0 = steady on. + void SetCaretPeriod (int milliseconds); + + // Set the set of characters making up words for when moving or selecting by word. + // First sets deaults like SetCharsDefault. + void SetWordChars (const wxString& characters); + + // Start a sequence of actions that is undone and redone as a unit. + // May be nested. + void BeginUndoAction(); + + // End a sequence of actions that is undone and redone as a unit. + void EndUndoAction(); + + // Set an indicator to plain, squiggle or TT. + void IndicatorSetStyle (int indic, int style); + + // Retrieve the style of an indicator. + int IndicatorGetStyle (int indic); + + // Set the foreground colour of an indicator. + void IndicatorSetForeground (int indic, const wxColour& fore); + + // Retrieve the foreground colour of an indicator. + wxColour IndicatorGetForeground (int indic); + + // Set the foreground colour of all whitespace and whether to use this setting. + void SetWhitespaceForeground (bool useSetting, const wxColour& fore); + + // Set the background colour of all whitespace and whether to use this setting. + void SetWhitespaceBackground (bool useSetting, const wxColour& back); + + // Divide each styling byte into lexical class bits (default: 5) and indicator + // bits (default: 3). If a lexer requires more than 32 lexical states, then this + // is used to expand the possible states. + void SetStyleBits (int bits); + + // Retrieve number of bits in style bytes used to hold the lexical state. + int GetStyleBits(); + + // Used to hold extra styling information for each line. + void SetLineState (int line, int state); + + // Retrieve the extra styling information for a line. + int GetLineState (int line); + + // Retrieve the last line number that has line state. + int GetMaxLineState(); + + // Is the background of the line containing the caret in a different colour? + bool GetCaretLineVisible(); + + // Display the background of the line containing the caret in a different colour. + void SetCaretLineVisible (bool show); + + // Get the colour of the background of the line containing the caret. + wxColour GetCaretLineBackground(); + + // Set the colour of the background of the line containing the caret. + void SetCaretLineBackground (const wxColour& back); + + // Set a style to be changeable or not (read only). + // Experimental feature, currently buggy. + void StyleSetChangeable (int style, bool changeable); + + // Display a auto-completion list. + // The lenEntered parameter indicates how many characters before + // the caret should be used to provide context. + void AutoCompShow (int lenEntered, const wxString& itemList); + + // Remove the auto-completion list from the screen. + void AutoCompCancel(); + + // Is there an auto-completion list visible? + bool AutoCompActive(); + + // Retrieve the position of the caret when the auto-completion list was displayed. + int AutoCompPosStart(); + + // User has selected an item so remove the list and insert the selection. + void AutoCompComplete(); + + // Define a set of character that when typed cancel the auto-completion list. + void AutoCompStops (const wxString& characterSet); + + // Change the separator character in the string setting up an auto-completion list. + // Default is space but can be changed if items contain space. + void AutoCompSetSeparator (int separatorCharacter); + + // Retrieve the auto-completion list separator character. + int AutoCompGetSeparator(); + + // Select the item in the auto-completion list that starts with a string. + void AutoCompSelect (const wxString& text); + + // Should the auto-completion list be cancelled if the user backspaces to a + // position before where the box was created. + void AutoCompSetCancelAtStart (bool cancel); + + // Retrieve whether auto-completion cancelled by backspacing before start. + bool AutoCompGetCancelAtStart(); + + // Define a set of characters that when typed will cause the autocompletion to + // choose the selected item. + void AutoCompSetFillUps (const wxString& characterSet); + + // Should a single item auto-completion list automatically choose the item. + void AutoCompSetChooseSingle (bool chooseSingle); + + // Retrieve whether a single item auto-completion list automatically choose the item. + bool AutoCompGetChooseSingle(); + + // Set whether case is significant when performing auto-completion searches. + void AutoCompSetIgnoreCase (bool ignoreCase); + + // Retrieve state of ignore case flag. + bool AutoCompGetIgnoreCase(); + + // Display a list of strings and send notification when user chooses one. + void UserListShow (int listType, const wxString& itemList); + + // Set whether or not autocompletion is hidden automatically when nothing matches. + void AutoCompSetAutoHide (bool autoHide); + + // Retrieve whether or not autocompletion is hidden automatically when nothing matches. + bool AutoCompGetAutoHide(); + + // Set whether or not autocompletion deletes any word characters + // after the inserted text upon completion. + void AutoCompSetDropRestOfWord (bool dropRestOfWord); + + // Retrieve whether or not autocompletion deletes any word characters + // after the inserted text upon completion. + bool AutoCompGetDropRestOfWord(); + + // Register an image for use in autocompletion lists. + void RegisterImage (int type, const wxBitmap& bmp); + + // Clear all the registered images. + void ClearRegisteredImages(); + + // Retrieve the auto-completion list type-separator character. + int AutoCompGetTypeSeparator(); + + // Change the type-separator character in the string setting up an auto-completion list. + // Default is '?' but can be changed if items contain '?'. + void AutoCompSetTypeSeparator (int separatorCharacter); + + // Set the maximum width, in characters, of auto-completion and user lists. + // Set to 0 to autosize to fit longest item, which is the default. + void AutoCompSetMaxWidth (int characterCount); + + // Get the maximum width, in characters, of auto-completion and user lists. + int AutoCompGetMaxWidth(); + + // Set the maximum height, in rows, of auto-completion and user lists. + // The default is 5 rows. + void AutoCompSetMaxHeight (int rowCount); + + // Set the maximum height, in rows, of auto-completion and user lists. + int AutoCompGetMaxHeight(); + + // Set the number of spaces used for one level of indentation. + void SetIndent (int indentSize); + + // Retrieve indentation size. + int GetIndent(); + + // Indentation will only use space characters if useTabs is false, otherwise + // it will use a combination of tabs and spaces. + void SetUseTabs (bool useTabs); + + // Retrieve whether tabs will be used in indentation. + bool GetUseTabs(); + + // Change the indentation of a line to a number of columns. + void SetLineIndentation (int line, int indentSize); + + // Retrieve the number of columns that a line is indented. + int GetLineIndentation (int line); + + // Retrieve the position before the first non indentation character on a line. + int GetLineIndentPosition (int line); + + // Retrieve the column number of a position, taking tab width into account. + int GetColumn (int pos); + + // Returns the position of a column (max. end of line position if beyond) + // on a line taking the width of tabs into account. + int FindColumn (int line, int column); + + // Can the caret preferred x position only be changed by explicit movement commands? + bool GetCaretSticky (); + + // Stop the caret preferred x position changing when the user types. + void SetCaretSticky (bool useCaretStickyBehaviour); + + // Switch between sticky and non-sticky: meant to be bound to a key. + void ToggleCaretSticky (); + + // Enable/Disable convert-on-paste for line endings. + void SetPasteConvertEndings (bool convert); + + // Get convert-on-paste setting. + bool GetPasteConvertEndings (); + + // Duplicate the selection. If selection empty duplicate the line containing the caret. + void SelectionDuplicate (); + + // Get the background alpha of the caret line. + int GetCaretLineBackgroundAlpha (); + + // Set background alpha of the caret line. + void SetCaretLineBackgroundAlpha (int alpha); + + // Show or hide the horizontal scroll bar. + void SetUseHorizontalScrollBar (bool show); + + // Is the horizontal scroll bar visible? + bool GetUseHorizontalScrollBar(); + + // Show or hide indentation guides. + void SetIndentationGuides (int show); + + // Are the indentation guides visible? + int GetIndentationGuides(); + + // Set the highlighted indentation guide column. + // 0 = no highlighted guide. + void SetHighlightGuide (int column); + + // Get the highlighted indentation guide column. + int GetHighlightGuide(); + + // Get the position after the last visible characters on a line. + int GetLineEndPosition (int line); + + // Get the code page used to interpret the bytes of the document as characters. + int GetCodePage(); + + // Get the foreground colour of the caret. + wxColour GetCaretForeground(); + + // In read-only mode? + bool GetReadOnly(); + + // Sets the position of the caret. + void SetCurrentPos (int pos); + + // Sets the position that starts the selection - this becomes the anchor. + void SetSelectionStart (int pos); + + // Returns the position at the start of the selection. + virtual int GetSelectionStart(); + + // Sets the position that ends the selection - this becomes the currentPosition. + void SetSelectionEnd (int pos); + + // Returns the position at the end of the selection. + int GetSelectionEnd(); + + // Sets the print magnification added to the point size of each style for printing. + void SetPrintMagnification (int magnification); + + // Returns the print magnification. + int GetPrintMagnification(); + + // Modify colours when printing for clearer printed text. + void SetPrintColourMode (int mode); + + // Returns the print colour mode. + int GetPrintColourMode(); + + // Find some text in the document. + int FindText (int minPos, int maxPos, const wxString& text, int flags=0, int* lengthFound = NULL); + + // On Windows, will draw the document into a display context such as a printer. + int FormatRange (bool doDraw, int startPos, int endPos, wxDC* draw, wxDC* target, wxRect renderRect, wxRect pageRect); + + // Retrieve the display line at the top of the display. + int GetFirstVisibleLine(); + + // Retrieve the contents of a line. + wxString GetLine (int line); + + // Returns the number of lines in the document. There is always at least one. + int GetLineCount(); + + // Sets the size in pixels of the left margin. + void SetMarginLeft (int pixels); + + // Returns the size in pixels of the left margin. + int GetMarginLeft(); + + // Sets the size in pixels of the right margin. + void SetMarginRight (int pixels); + + // Returns the size in pixels of the right margin. + int GetMarginRight(); + + // Is the document different from when it was last saved? + bool GetModify(); + + // Select a range of text. + void SetSelection (int startPos, int endPos); + + // Retrieve the selected text. + wxString GetSelectedText(); + + // Retrieve a range of text. + wxString GetTextRange (int startPos, int endPos); + + // Draw the selection in normal style or with selection highlighted. + void HideSelection (bool hide); + + // Retrieve the line containing a position. + int LineFromPosition (int pos); + + // Retrieve the position at the start of a line. + int PositionFromLine (int line); + + // Scroll horizontally and vertically. + void LineScroll (int columns, int lines); + + // Ensure the caret is visible. + void EnsureCaretVisible(); + + // Replace the selected text with the argument text. + void ReplaceSelection (const wxString& text); + + // Set to read only or read write. + void SetReadOnly (bool readOnly); + + // Will a paste succeed? + bool CanPaste(); + + // Are there any undoable actions in the undo history? + bool CanUndo(); + + // Delete the undo history. + void EmptyUndoBuffer(); + + // Undo one action in the undo history. + void Undo(); + + // Cut the selection to the clipboard. + void Cut(); + + // Copy the selection to the clipboard. + void Copy(); + + // Paste the contents of the clipboard into the document replacing the selection. + void Paste(); + + // Clear the selection. + void Clear(); + + // Replace the contents of the document with the argument text. + void SetText (const wxString& text); + + // Retrieve all the text in the document. + wxString GetText(); + + // Retrieve the number of characters in the document. + int GetTextLength(); + + // Set to overtype (true) or insert mode. + void SetOvertype (bool overtype); + + // Returns true if overtype mode is active otherwise false is returned. + bool GetOvertype(); + + // Set the width of the insert mode caret. + void SetCaretWidth (int pixels); + + // Returns the width of the insert mode caret. + int GetCaretWidth(); + + // Sets the position that starts the target which is used for updating the + // document without affecting the scroll position. + void SetTargetStart (int pos); + + // Get the position that starts the target. + int GetTargetStart(); + + // Sets the position that ends the target which is used for updating the + // document without affecting the scroll position. + void SetTargetEnd (int pos); + + // Get the position that ends the target. + int GetTargetEnd(); + + // Replace the target text with the argument text. + // Text is counted so it can contain NULs. + // Returns the length of the replacement text. + int ReplaceTarget (const wxString& text); + + // Replace the target text with the argument text after \d processing. + // Text is counted so it can contain NULs. + // Looks for \d where d is between 1 and 9 and replaces these with the strings + // matched in the last search operation which were surrounded by \( and \). + // Returns the length of the replacement text including any change + // caused by processing the \d patterns. + int ReplaceTargetRE (const wxString& text); + + // Search for a counted string in the target and set the target to the found + // range. Text is counted so it can contain NULs. + // Returns length of range or -1 for failure in which case target is not moved. + int SearchInTarget (const wxString& text); + + // Set the search flags used by SearchInTarget. + void SetSearchFlags (int flags); + + // Get the search flags used by SearchInTarget. + int GetSearchFlags(); + + // Show a call tip containing a definition near position pos. + void CallTipShow (int pos, const wxString& definition); + + // CodeLite related: show call tip at given pos but 250pixles to the top / right + void CallTipShowExt (int pos, const wxString& definition); + + // Remove the call tip from the screen. + void CallTipCancel(); + + // Is there an active call tip? + bool CallTipActive(); + + // Retrieve the position where the caret was before displaying the call tip. + int CallTipPosAtStart(); + + // Highlight a segment of the definition. + void CallTipSetHighlight (int startPos, int endPos); + + // Set the background colour for the call tip. + void CallTipSetBackground (const wxColour& back); + + // Set the foreground colour for the call tip. + void CallTipSetForeground (const wxColour& fore); + + // Set the foreground colour for the highlighted part of the call tip. + void CallTipSetForegroundHighlight (const wxColour& fore); + + // Enable use of STYLE_CALLTIP and set call tip tab size in pixels. + void CallTipUseStyle (int tabSize); + + // Find the display line of a document line taking hidden lines into account. + int VisibleFromDocLine (int line); + + // Find the document line of a display line taking hidden lines into account. + int DocLineFromVisible (int lineDisplay); + + // The number of display lines needed to wrap a document line + int WrapCount (int line); + + // Set the fold level of a line. + // This encodes an integer level along with flags indicating whether the + // line is a header and whether it is effectively white space. + void SetFoldLevel (int line, int level); + + // Retrieve the fold level of a line. + int GetFoldLevel (int line); + + // Find the last child line of a header line. + int GetLastChild (int line, int level); + + // Find the parent line of a child line. + int GetFoldParent (int line); + + // Make a range of lines visible. + void ShowLines (int lineStart, int lineEnd); + + // Make a range of lines invisible. + void HideLines (int lineStart, int lineEnd); + + // Is a line visible? + bool GetLineVisible (int line); + + // Show the children of a header line. + void SetFoldExpanded (int line, bool expanded); + + // Is a header line expanded? + bool GetFoldExpanded (int line); + + // Switch a header line between expanded and contracted. + void ToggleFold (int line); + + // Ensure a particular line is visible by expanding any header line hiding it. + void EnsureVisible (int line); + + // Set some style options for folding. + void SetFoldFlags (int flags); + + // Ensure a particular line is visible by expanding any header line hiding it. + // Use the currently set visibility policy to determine which range to display. + void EnsureVisibleEnforcePolicy (int line); + + // Sets whether a tab pressed when caret is within indentation indents. + void SetTabIndents (bool tabIndents); + + // Does a tab pressed when caret is within indentation indent? + bool GetTabIndents(); + + // Sets whether a backspace pressed when caret is within indentation unindents. + void SetBackSpaceUnIndents (bool bsUnIndents); + + // Does a backspace pressed when caret is within indentation unindent? + bool GetBackSpaceUnIndents(); + + // Sets the time the mouse must sit still to generate a mouse dwell event. + void SetMouseDwellTime (int periodMilliseconds); + + // Retrieve the time the mouse must sit still to generate a mouse dwell event. + int GetMouseDwellTime(); + + // Get position of start of word. + int WordStartPosition (int pos, bool onlyWordCharacters); + + // Get position of end of word. + int WordEndPosition (int pos, bool onlyWordCharacters); + + // Sets whether text is word wrapped. + void SetWrapMode (int mode); + + // Retrieve whether text is word wrapped. + int GetWrapMode(); + + // Set the display mode of visual flags for wrapped lines. + void SetWrapVisualFlags (int wrapVisualFlags); + + // Retrive the display mode of visual flags for wrapped lines. + int GetWrapVisualFlags(); + + // Set the location of visual flags for wrapped lines. + void SetWrapVisualFlagsLocation (int wrapVisualFlagsLocation); + + // Retrive the location of visual flags for wrapped lines. + int GetWrapVisualFlagsLocation(); + + // Set the start indent for wrapped lines. + void SetWrapStartIndent (int indent); + + // Retrive the start indent for wrapped lines. + int GetWrapStartIndent(); + + // Sets the degree of caching of layout information. + void SetLayoutCache (int mode); + + // Retrieve the degree of caching of layout information. + int GetLayoutCache(); + + // Sets the document width assumed for scrolling. + void SetScrollWidth (int pixels); + + // Retrieve the document width assumed for scrolling. + int GetScrollWidth(); + + // Measure the pixel width of some text in a particular style. + // NUL terminated text argument. + // Does not handle tab or control characters. + int TextWidth (int style, const wxString& text); + + // Sets the scroll range so that maximum scroll position has + // the last line at the bottom of the view (default). + // Setting this to false allows scrolling one page below the last line. + void SetEndAtLastLine (bool endAtLastLine); + + // Retrieve whether the maximum scroll position has the last + // line at the bottom of the view. + bool GetEndAtLastLine(); + + // Retrieve the height of a particular line of text in pixels. + int TextHeight (int line); + + // Show or hide the vertical scroll bar. + void SetUseVerticalScrollBar (bool show); + + // Is the vertical scroll bar visible? + bool GetUseVerticalScrollBar(); + + // Append a string to the end of the document without changing the selection. + void AppendText (const wxString& text); + void AppendText (int length, const wxString& text); + + // Is drawing done in two phases with backgrounds drawn before foregrounds? + bool GetTwoPhaseDraw(); + + // In twoPhaseDraw mode, drawing is performed in two phases, first the background + // and then the foreground. This avoids chopping off characters that overlap the next run. + void SetTwoPhaseDraw (bool twoPhase); + + // Make the target range start and end be the same as the selection range start and end. + void TargetFromSelection(); + + // Join the lines in the target. + void LinesJoin(); + + // Split the lines in the target into lines that are less wide than pixelWidth + // where possible. + void LinesSplit (int pixels); + + // Set the colours used as a chequerboard pattern in the fold margin + void SetFoldMarginColour (bool useSetting, const wxColour& back); + void SetFoldMarginHiColour (bool useSetting, const wxColour& fore); + + // Move caret down one line. + void LineDown(); + + // Move caret down one line extending selection to new caret position. + void LineDownExtend(); + + // Move caret up one line. + void LineUp(); + + // Move caret up one line extending selection to new caret position. + void LineUpExtend(); + + // Move caret left one character. + void CharLeft(); + + // Move caret left one character extending selection to new caret position. + void CharLeftExtend(); + + // Move caret right one character. + void CharRight(); + + // Move caret right one character extending selection to new caret position. + void CharRightExtend(); + + // Move caret left one word. + void WordLeft(); + + // Move caret left one word extending selection to new caret position. + void WordLeftExtend(); + + // Move caret right one word. + void WordRight(); + + // Move caret right one word extending selection to new caret position. + void WordRightExtend(); + + // Move caret to first position on line. + void Home(); + + // Move caret to first position on line extending selection to new caret position. + void HomeExtend(); + + // Move caret to last position on line. + void LineEnd(); + + // Move caret to last position on line extending selection to new caret position. + void LineEndExtend(); + + // Move caret to first position in document. + void DocumentStart(); + + // Move caret to first position in document extending selection to new caret position. + void DocumentStartExtend(); + + // Move caret to last position in document. + void DocumentEnd(); + + // Move caret to last position in document extending selection to new caret position. + void DocumentEndExtend(); + + // Move caret one page up. + void PageUp(); + + // Move caret one page up extending selection to new caret position. + void PageUpExtend(); + + // Move caret one page down. + void PageDown(); + + // Move caret one page down extending selection to new caret position. + void PageDownExtend(); + + // Switch from insert to overtype mode or the reverse. + void EditToggleOvertype(); + + // Cancel any modes such as call tip or auto-completion list display. + void Cancel(); + + // Delete the selection or if no selection, the character before the caret. + void DeleteBack(); + + // If selection is empty or all on one line replace the selection with a tab character. + // If more than one line selected, indent the lines. + void Tab(); + + // Dedent the selected lines. + void BackTab(); + + // Insert a new line, may use a CRLF, CR or LF depending on EOL mode. + void NewLine(); + + // Insert a Form Feed character. + void FormFeed(); + + // Move caret to before first visible character on line. + // If already there move to first character on line. + void VCHome(); + + // Like VCHome but extending selection to new caret position. + void VCHomeExtend(); + + // Magnify the displayed text by increasing the sizes by 1 point. + void ZoomIn(); + + // Make the displayed text smaller by decreasing the sizes by 1 point. + void ZoomOut(); + + // Delete the word to the left of the caret. + void DelWordLeft(); + + // Delete the word to the right of the caret. + void DelWordRight(); + + // Cut the line containing the caret. + void LineCut(); + + // Delete the line containing the caret. + void LineDelete(); + + // Switch the current line with the previous. + void LineTranspose(); + + // Duplicate the current line. + void LineDuplicate(); + + // Transform the selection to lower case. + void LowerCase(); + + // Transform the selection to upper case. + void UpperCase(); + + // Scroll the document down, keeping the caret visible. + void LineScrollDown(); + + // Scroll the document up, keeping the caret visible. + void LineScrollUp(); + + // Delete the selection or if no selection, the character before the caret. + // Will not delete the character before at the start of a line. + void DeleteBackNotLine(); + + // Move caret to first position on display line. + void HomeDisplay(); + + // Move caret to first position on display line extending selection to + // new caret position. + void HomeDisplayExtend(); + + // Move caret to last position on display line. + void LineEndDisplay(); + + // Move caret to last position on display line extending selection to new + // caret position. + void LineEndDisplayExtend(); + + // These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)? + // except they behave differently when word-wrap is enabled: + // They go first to the start / end of the display line, like (Home|LineEnd)Display + // The difference is that, the cursor is already at the point, it goes on to the start + // or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?. + void HomeWrap(); + void HomeWrapExtend(); + void LineEndWrap(); + void LineEndWrapExtend(); + void VCHomeWrap(); + void VCHomeWrapExtend(); + + // Copy the line containing the caret. + void LineCopy(); + + // works the same as SCI_COPY except that if the selection is empty then the current line is copied. + // On Windows, an extra "MSDEVLineSelect" marker is added to the clipboard which is then used in SCI_PASTE to paste the whole line before the current line. + void CopyAllowLine(); + + // Move the caret inside current view if it's not there already. + void MoveCaretInsideView(); + + // How many characters are on a line, not including end of line characters? + int LineLength (int line); + + // Highlight the characters at two positions. + void BraceHighlight (int pos1, int pos2); + + // Highlight the character at a position indicating there is no matching brace. + void BraceBadLight (int pos); + + // Find the position of a matching brace or INVALID_POSITION if no match. + int BraceMatch (int pos); + + // Are the end of line characters visible? + bool GetViewEOL(); + + // Make the end of line characters visible or invisible. + void SetViewEOL (bool visible); + + // Retrieve a pointer to the document object. + void* GetDocPointer(); + + // Change the document object used. + void SetDocPointer (void* docPointer); + + // Set which document modification events are sent to the container. + void SetModEventMask (int mask); + + // Retrieve the column number which text should be kept within. + int GetEdgeColumn(); + + // Set the column number of the edge. + // If text goes past the edge then it is highlighted. + void SetEdgeColumn (int column); + + // Retrieve the edge highlight mode. + int GetEdgeMode(); + + // The edge may be displayed by a line (EDGE_LINE) or by highlighting text that + // goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE). + void SetEdgeMode (int mode); + + // Retrieve the colour used in edge indication. + wxColour GetEdgeColour(); + + // Change the colour used in edge indication. + void SetEdgeColour (const wxColour& colour); + + // Sets the current caret position to be the search anchor. + void SearchAnchor(); + + // Find some text starting at the search anchor. + // Does not ensure the selection is visible. + int SearchNext (int flags, const wxString& text); + + // Find some text starting at the search anchor and moving backwards. + // Does not ensure the selection is visible. + int SearchPrev (int flags, const wxString& text); + + // Retrieves the number of lines completely visible. + int LinesOnScreen(); + + // Set whether a pop up menu is displayed automatically when the user presses + // the wrong mouse button. + void UsePopUp (bool allowPopUp); + + // Is the selection rectangular? The alternative is the more common stream selection. + bool SelectionIsRectangle(); + + // Set the zoom level. This number of points is added to the size of all fonts. + // It may be positive to magnify or negative to reduce. + void SetZoom (int zoom); + + // Retrieve the zoom level. + int GetZoom(); + + // Create a new document object. + // Starts with reference count of 1 and not selected into editor. + void* CreateDocument(); + + // Extend life of document. + void AddRefDocument (void* docPointer); + + // Release a reference to the document, deleting document if it fades to black. + void ReleaseDocument (void* docPointer); + + // Get which document modification events are sent to the container. + int GetModEventMask(); + + // Change internal focus flag. + void SetSCIFocus (bool focus); + + // Get internal focus flag. + bool GetSCIFocus(); + + // Change error status - 0 = OK. + void SetStatus (int status); + + // Get error status. + int GetStatus(); + + // Set whether the mouse is captured when its button is pressed. + void SetMouseDownCaptures (bool captures); + + // Get whether mouse gets captured. + bool GetMouseDownCaptures(); + + // Sets the cursor to one of the SC_CURSOR* values. + void SetCursorType (int cursorType); + + // Get cursor type. + int GetCursorType(); + + // Change the way control characters are displayed: + // If symbol is < 32, keep the drawn way, else, use the given character. + void SetControlCharSymbol (int symbol); + + // Get the way control characters are displayed. + int GetControlCharSymbol(); + + // Move to the previous change in capitalisation. + void WordPartLeft(); + + // Move to the previous change in capitalisation extending selection + // to new caret position. + void WordPartLeftExtend(); + + // Move to the change next in capitalisation. + void WordPartRight(); + + // Move to the next change in capitalisation extending selection + // to new caret position. + void WordPartRightExtend(); + + // Set the way the display area is determined when a particular line + // is to be moved to by Find, FindNext, GotoLine, etc. + void SetVisiblePolicy (int visiblePolicy, int visibleSlop); + + // Delete back from the current position to the start of the line. + void DelLineLeft(); + + // Delete forwards from the current position to the end of the line. + void DelLineRight(); + + // Get and Set the xOffset (ie, horizonal scroll position). + void SetXOffset (int newOffset); + int GetXOffset(); + + // Set the last x chosen value to be the caret x position. + void ChooseCaretX(); + + // Set the way the caret is kept visible when going sideway. + // The exclusion zone is given in pixels. + void SetXCaretPolicy (int caretPolicy, int caretSlop); + + // Set the way the line the caret is on is kept visible. + // The exclusion zone is given in lines. + void SetYCaretPolicy (int caretPolicy, int caretSlop); + + // Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE). + void SetPrintWrapMode (int mode); + + // Is printing line wrapped? + int GetPrintWrapMode(); + + // Set a fore colour for active hotspots. + void SetHotspotActiveForeground (bool useSetting, const wxColour& fore); + + // Set a back colour for active hotspots. + void SetHotspotActiveBackground (bool useSetting, const wxColour& back); + + // Enable / Disable underlining active hotspots. + void SetHotspotActiveUnderline (bool underline); + + // Limit hotspots to single line so hotspots on two lines don't merge. + void SetHotspotSingleLine (bool singleLine); + + // Move caret between paragraphs (delimited by empty lines). + void ParaDown(); + void ParaDownExtend(); + void ParaUp(); + void ParaUpExtend(); + + // Given a valid document position, return the previous position taking code + // page into account. Returns 0 if passed 0. + int PositionBefore (int pos); + + // Given a valid document position, return the next position taking code + // page into account. Maximum value returned is the last position in the document. + int PositionAfter (int pos); + + // Copy a range of text to the clipboard. Positions are clipped into the document. + void CopyRange (int startPos, int endPos); + + // Copy argument text to the clipboard. + void CopyText (int length, const wxString& text); + + // Set the selection mode to stream (SC_SEL_STREAM=1) or rectangular (SC_SEL_RECTANGLE=2) or + // by lines (SC_SEL_LINES=3). + void SetSelectionMode (int mode); + + // Get the mode of the current selection. + int GetSelectionMode(); + + // Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line). + int GetLineSelStartPosition (int line); + + // Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line). + int GetLineSelEndPosition (int line); + + // Move caret down one line, extending rectangular selection to new caret position. + void LineDownRectExtend(); + + // Move caret up one line, extending rectangular selection to new caret position. + void LineUpRectExtend(); + + // Move caret left one character, extending rectangular selection to new caret position. + void CharLeftRectExtend(); + + // Move caret right one character, extending rectangular selection to new caret position. + void CharRightRectExtend(); + + // Move caret to first position on line, extending rectangular selection to new caret position. + void HomeRectExtend(); + + // Move caret to before first visible character on line. + // If already there move to first character on line. + // In either case, extend rectangular selection to new caret position. + void VCHomeRectExtend(); + + // Move caret to last position on line, extending rectangular selection to new caret position. + void LineEndRectExtend(); + + // Move caret one page up, extending rectangular selection to new caret position. + void PageUpRectExtend(); + + // Move caret one page down, extending rectangular selection to new caret position. + void PageDownRectExtend(); + + // Move caret to top of page, or one page up if already at top of page. + void StutteredPageUp(); + + // Move caret to top of page, or one page up if already at top of page, extending selection to new caret position. + void StutteredPageUpExtend(); + + // Move caret to bottom of page, or one page down if already at bottom of page. + void StutteredPageDown(); + + // Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position. + void StutteredPageDownExtend(); + + // Move caret left one word, position cursor at end of word. + void WordLeftEnd(); + + // Move caret left one word, position cursor at end of word, extending selection to new caret position. + void WordLeftEndExtend(); + + // Move caret right one word, position cursor at end of word. + void WordRightEnd(); + + // Move caret right one word, position cursor at end of word, extending selection to new caret position. + void WordRightEndExtend(); + + // Set the set of characters making up whitespace for when moving or selecting by word. + // Should be called after SetWordChars. + void SetWhitespaceChars (const wxString& characters); + + // Reset the set of characters for whitespace and word characters to the defaults. + void SetCharsDefault(); + + // Get currently selected item position in the auto-completion list + int AutoCompGetCurrent(); + + // Enlarge the document to a particular size of text bytes. + void Allocate (int bytes); + + // Start notifying the container of all key presses and commands. + void StartRecord(); + + // Stop notifying the container of all key presses and commands. + void StopRecord(); + + // Set the lexing language of the document. + void SetLexer (int lexer); + + // Retrieve the lexing language of the document. + int GetLexer(); + + // Colourise a segment of the document using the current lexing language. + void Colourise (int startPos, int endPos); + + // Set up a value that may be used by a lexer for some optional feature. + void SetProperty (const wxString& key, const wxString& value); + + // Retrieve a value that may be used by a lexer for some optional feature. + wxString GetProperty (const wxString& key); + wxString GetPropertyExpanded (const wxString& key); + int GetPropertyInt (const wxString& key); + + // Retrieve the number of bits the current lexer needs for styling. + int GetStyleBitsNeeded (); + + // Set up the key words used by the lexer. + void SetKeyWords (int keywordSet, const wxString& keyWords); + + // Set the lexing language of the document based on string name. + void SetLexerLanguage (const wxString& language); + +// END of generated section +//---------------------------------------------------------------------- +// Others... + + + // Returns the line number of the line with the caret. + int GetCurrentLine(); + + // Extract style settings from a spec-string which is composed of one or + // more of the following comma separated elements: + // + // bold turns on bold + // italic turns on italics + // fore:[name or #RRGGBB] sets the foreground colour + // back:[name or #RRGGBB] sets the background colour + // face:[facename] sets the font face name to use + // size:[num] sets the font size in points + // eol turns on eol filling + // underline turns on underlining + // + void StyleSetSpec (int styleNum, const wxString& spec); + + // Set style size, face, bold, italic, and underline attributes from + // a wxFont's attributes. + void StyleSetFont (int styleNum, const wxFont& font); + + // Set all font style attributes at once. + void StyleSetFontAttr (int styleNum, int size,const wxString& faceName, + bool bold, bool italic, bool underline, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT); + + // Set the character set of the font in a style. + void StyleSetCharacterSet (int style, int characterSet); + + // Set the font encoding to be used by a style. + void StyleSetFontEncoding (int style, wxFontEncoding encoding); + + // Perform one of the operations defined by the wxSCI_CMD_* constants. + void CmdKeyExecute (int cmd); + + // Set the left and right margin in the edit area, measured in pixels. + void SetMargins (int left, int right); + + // Retrieve the start and end positions of the current selection. +#ifdef SWIG + void GetSelection (int* OUTPUT, int* OUTPUT); +#else + void GetSelection (int* startPos, int* endPos); +#endif + + // Retrieve the point in the window where a position is displayed. + wxPoint PointFromPosition (int pos); + + // Scroll enough to make the given line visible + void ScrollToLine (int line); + + // Scroll enough to make the given column visible + void ScrollToColumn (int column); + + // Send a message to Scintilla + long SendMsg (int msg, long wp=0, long lp=0); + + + // Set the vertical scrollbar to use instead of the ont that's built-in. + void SetVScrollBar (wxScrollBar* bar); + + // Set the horizontal scrollbar to use instead of the ont that's built-in. + void SetHScrollBar (wxScrollBar* bar); + + // Can be used to prevent the EVT_CHAR handler from adding the char + bool GetLastKeydownProcessed() { return m_lastKeyDownConsumed; } + void SetLastKeydownProcessed (bool val) { m_lastKeyDownConsumed = val; } + + // Write the contents of the editor to filename + bool SaveFile (const wxString& filename); + + // Load the contents of filename into the editor + bool LoadFile (const wxString& filename); + +#ifdef SCI_USE_DND + // Allow for simulating a DnD DragOver + wxDragResult DoDragOver (wxCoord x, wxCoord y, wxDragResult def); + + // Allow for simulating a DnD DropText + bool DoDropText (long x, long y, const wxString& data); + + // Allow for simulating a DnD DragEnter + wxDragResult DoDragEnter (wxCoord x, wxCoord y, wxDragResult def); + + // Allow for simulating a DnD DragEnter + void DoDragLeave (); + +#endif + + // Specify whether anti-aliased fonts should be used. Will have no effect + // on some platforms, but on some (wxMac for example) can greatly improve + // performance. + void SetUseAntiAliasing (bool useAA); + + // Returns the current UseAntiAliasing setting. + bool GetUseAntiAliasing(); + + // [PATCH] Starts + void SetScrollWidthTracking(bool tracking); + bool GetScrollWidthTracking(); + + // Modern indicators + void SetIndicatorCurrent(int indicator); + int GetIndicatorCurrent(); + int IndicatorValueAt(int indicator, int position); + void SetInidicatorValue(int indicator, int value); + void IndicatorFillRange(int position, int len); + void IndicatorClearRange(int position, int len); + int IndicatorStart(int indicator, int position); + int IndicatorEnd(int indicator, int position); + void IndicatorSetUnder(int indicator, bool under); + void IndicatorSetAlpha(int indicatorNumber, int alpha); + int IndicatorGetAlpha(int indicatorNumber); + void AnnotationSetText(int line, const wxString &text); + wxString AnnotationGetText(int line); + void AnnotationSetStyle(int line, int style); + int AnnotationGetStyle(int line); + void AnnotationClearAll(); + void AnnotationSetVisible(int visible); + bool AnnotationGetVisible(); + void AnnotationSetStyleOffset(int style); + void AnnotationSetStyles(int line, const wxMemoryBuffer &styles); + void MarginSetText(int line, const wxString &text); + void MarginSetStyle(int line, int style); + void MarginTextClearAll(); + int MarginGetStyle(int line); + + // Multiple selection + void SetMultipleSelection(bool multipleSelection); + bool GetMultipleSelection(); + bool GetAdditionalSelectionTyping(); + void SetAdditionalSelectionTyping(bool additionalSelectionTyping); + void SetRectangularSelectionModifier(int mod); + int GetRectangularSelectionModifier(); + // [PATCH] END + +#if wxCHECK_VERSION(2, 5, 0) + // The following methods are nearly equivallent to their similarly named + // cousins above. The difference is that these methods bypass wxString + // and always use a char* even if used in a unicode build of wxWidgets. + // In that case the character data will be utf-8 encoded since that is + // what is used internally by Scintilla in unicode builds. + + // Add text to the document at current position. + void AddTextRaw (const char* text); + + // Insert string at a position. + void InsertTextRaw (int pos, const char* text); + + // Retrieve the text of the line containing the caret. + // Returns the index of the caret on the line. +#ifdef SWIG + wxCharBuffer GetCurLineRaw (int* OUTPUT); +#else + wxCharBuffer GetCurLineRaw (int* linePos = NULL); +#endif + + // Retrieve the contents of a line. + wxCharBuffer GetLineRaw (int line); + + // Retrieve the selected text. + wxCharBuffer GetSelectedTextRaw(); + + // Retrieve a range of text. + wxCharBuffer GetTextRangeRaw (int startPos, int endPos); + + // Replace the contents of the document with the argument text. + void SetTextRaw (const char* text); + + // Retrieve all the text in the document. + wxCharBuffer GetTextRaw(); + + // Append a string to the end of the document without changing the selection. + void AppendTextRaw (const char* text); + +#ifdef SWIG + %pythoncode "_stc_utf8_methods.py" +#endif +#endif + + +//---------------------------------------------------------------------- + +#ifndef SWIG +protected: + // Event handlers + void OnPaint (wxPaintEvent& evt); + void OnScrollWin (wxScrollWinEvent& evt); + void OnScroll (wxScrollEvent& evt); + void OnSize (wxSizeEvent& evt); + void OnMouseLeftDown (wxMouseEvent& evt); + void OnMouseMove (wxMouseEvent& evt); + void OnMouseLeftUp (wxMouseEvent& evt); + void OnMouseRightUp (wxMouseEvent& evt); + void OnMouseMiddleUp (wxMouseEvent& evt); + void OnContextMenu (wxContextMenuEvent& evt); + void OnMouseWheel (wxMouseEvent& evt); + void OnChar (wxKeyEvent& evt); + void OnKeyDown (wxKeyEvent& evt); + void OnLoseFocus (wxFocusEvent& evt); + void OnGainFocus (wxFocusEvent& evt); + void OnSysColourChanged (wxSysColourChangedEvent& evt); + void OnEraseBackground (wxEraseEvent& evt); + void OnMenu (wxCommandEvent& evt); + void OnListBox (wxCommandEvent& evt); + void OnIdle (wxIdleEvent& evt); + + virtual wxSize DoGetBestSize() const; + + // Turn notifications from Scintilla into events + void NotifyChange(); + void NotifyParent (SCI_SCOPE(SCNotification*) scn); // [CHAGED] + + ScintillaWX* m_swx; + wxStopWatch m_stopWatch; + wxScrollBar* m_vScrollBar; + wxScrollBar* m_hScrollBar; + bool m_lastKeyDownConsumed; + + // ERAN IFRAH +public: + wxPoint m_ccPoint; + bool m_isTipBgDark; + // END + friend class ScintillaWX; + friend class Platform; + +private: + DECLARE_EVENT_TABLE() + //DECLARE_CLASS(wxScintilla) +#endif +}; + +//---------------------------------------------------------------------- + +class WXDLLIMPEXP_SCI wxScintillaEvent : public wxCommandEvent { +public: + wxScintillaEvent (wxEventType commandType=0, int id=0); +#ifndef SWIG + wxScintillaEvent (const wxScintillaEvent& event); +#endif + ~wxScintillaEvent() {} + + void SetPosition (int pos) { m_position = pos; } + void SetKey (int k) { m_key = k; } + void SetModifiers (int m) { m_modifiers = m; } + void SetModificationType (int t) { m_modificationType = t; } + void SetText (const wxString& t) { m_text = t; } + void SetLength (int len) { m_length = len; } + void SetLinesAdded (int num) { m_linesAdded = num; } + void SetLine (int val) { m_line = val; } + void SetFoldLevelNow (int val) { m_foldLevelNow = val; } + void SetFoldLevelPrev (int val) { m_foldLevelPrev = val; } + void SetMargin (int val) { m_margin = val; } + void SetMessage (int val) { m_message = val; } + void SetWParam (int val) { m_wParam = val; } + void SetLParam (int val) { m_lParam = val; } + void SetListType (int val) { m_listType = val; } + void SetX (int val) { m_x = val; } + void SetY (int val) { m_y = val; } + void SetDragText (const wxString& val) { m_dragText = val; } + void SetDragAllowMove (bool val) { m_dragAllowMove = val; } +#ifdef SCI_USE_DND + void SetDragResult (wxDragResult val) { m_dragResult = val; } +#endif + + int GetPosition() const { return m_position; } + int GetKey() const { return m_key; } + int GetModifiers() const { return m_modifiers; } + int GetModificationType() const { return m_modificationType; } + wxString GetText() const { return m_text; } + int GetLength() const { return m_length; } + int GetLinesAdded() const { return m_linesAdded; } + int GetLine() const { return m_line; } + int GetFoldLevelNow() const { return m_foldLevelNow; } + int GetFoldLevelPrev() const { return m_foldLevelPrev; } + int GetMargin() const { return m_margin; } + int GetMessage() const { return m_message; } + int GetWParam() const { return m_wParam; } + int GetLParam() const { return m_lParam; } + int GetListType() const { return m_listType; } + int GetX() const { return m_x; } + int GetY() const { return m_y; } + wxString GetDragText() { return m_dragText; } + bool GetDragAllowMove() { return wxDrag_DefaultMove; } +#ifdef SCI_USE_DND + wxDragResult GetDragResult() { return m_dragResult; } +#endif + + bool GetShift() const; + bool GetControl() const; + bool GetAlt() const; + + virtual wxEvent* Clone() const { return new wxScintillaEvent (*this); } + +#ifndef SWIG +private: + //DECLARE_CLASS(wxScintillaEvent) + + int m_position; + int m_key; + int m_modifiers; + + int m_modificationType; // wxEVT_SCI_MODIFIED + wxString m_text; + int m_length; + int m_linesAdded; + int m_line; + int m_foldLevelNow; + int m_foldLevelPrev; + + int m_margin; // wxEVT_SCI_MARGINCLICK + + int m_message; // wxEVT_SCI_MACRORECORD + int m_wParam; + int m_lParam; + + int m_listType; + int m_x; + int m_y; + + wxString m_dragText; // wxEVT_SCI_START_DRAG, wxEVT_SCI_DO_DROP + bool m_dragAllowMove; // wxEVT_SCI_START_DRAG + +#if wxUSE_DRAG_AND_DROP + wxDragResult m_dragResult; // wxEVT_SCI_DRAG_OVER,wxEVT_SCI_DO_DROP +#endif +#endif +}; + + + +#ifndef SWIG +BEGIN_DECLARE_EVENT_TYPES() +#if !wxCHECK_VERSION(2, 5, 0) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_CHANGE, 1650) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_STYLENEEDED, 1651) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_CHARADDED, 1652) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_SAVEPOINTREACHED, 1653) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_SAVEPOINTLEFT, 1654) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_ROMODIFYATTEMPT, 1655) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_KEY, 1656) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DOUBLECLICK, 1657) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_UPDATEUI, 1658) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_MODIFIED, 1659) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_MACRORECORD, 1660) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_MARGINCLICK, 1661) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_NEEDSHOWN, 1662) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_POSCHANGED, 1663) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_PAINTED, 1664) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_USERLISTSELECTION, 1665) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_URIDROPPED, 1666) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DWELLSTART, 1667) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DWELLEND, 1668) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_START_DRAG, 1669) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DRAG_OVER, 1670) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DO_DROP, 1671) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_ZOOM, 1672) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_HOTSPOT_CLICK, 1673) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_HOTSPOT_DCLICK, 1674) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_CALLTIP_CLICK, 1675) + DECLARE_EXPORTED_LOCAL_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_AUTOCOMP_SELECTION, 1676) +#else + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_CHANGE, 1650) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_STYLENEEDED, 1651) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_CHARADDED, 1652) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_SAVEPOINTREACHED, 1653) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_SAVEPOINTLEFT, 1654) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_ROMODIFYATTEMPT, 1655) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_KEY, 1656) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DOUBLECLICK, 1657) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_UPDATEUI, 1658) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_MODIFIED, 1659) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_MACRORECORD, 1660) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_MARGINCLICK, 1661) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_NEEDSHOWN, 1662) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_PAINTED, 1664) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_USERLISTSELECTION, 1665) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_URIDROPPED, 1666) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DWELLSTART, 1667) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DWELLEND, 1668) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_START_DRAG, 1669) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DRAG_OVER, 1670) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_DO_DROP, 1671) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_ZOOM, 1672) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_HOTSPOT_CLICK, 1673) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_HOTSPOT_DCLICK, 1674) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_CALLTIP_CLICK, 1675) + DECLARE_EXPORTED_EVENT_TYPE (WXDLLIMPEXP_SCI, wxEVT_SCI_AUTOCOMP_SELECTION, 1676) +#endif +END_DECLARE_EVENT_TYPES() +#else + enum { + wxEVT_SCI_CHANGE, + wxEVT_SCI_STYLENEEDED, + wxEVT_SCI_CHARADDED, + wxEVT_SCI_SAVEPOINTREACHED, + wxEVT_SCI_SAVEPOINTLEFT, + wxEVT_SCI_ROMODIFYATTEMPT, + wxEVT_SCI_KEY, + wxEVT_SCI_DOUBLECLICK, + wxEVT_SCI_UPDATEUI, + wxEVT_SCI_MODIFIED, + wxEVT_SCI_MACRORECORD, + wxEVT_SCI_MARGINCLICK, + wxEVT_SCI_NEEDSHOWN, + wxEVT_SCI_PAINTED, + wxEVT_SCI_USERLISTSELECTION, + wxEVT_SCI_URIDROPPED, + wxEVT_SCI_DWELLSTART, + wxEVT_SCI_DWELLEND, + wxEVT_SCI_START_DRAG, + wxEVT_SCI_DRAG_OVER, + wxEVT_SCI_DO_DROP, + wxEVT_SCI_ZOOM, + wxEVT_SCI_HOTSPOT_CLICK, + wxEVT_SCI_HOTSPOT_DCLICK, + wxEVT_SCI_CALLTIP_CLICK, + wxEVT_SCI_AUTOCOMP_SELECTION + }; +#endif + + + +#ifndef SWIG +typedef void (wxEvtHandler::*wxScintillaEventFunction)(wxScintillaEvent&); + +#if !wxCHECK_VERSION(2, 5, 0) +#define EVT_SCI_CHANGE(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_CHANGE, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_STYLENEEDED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_STYLENEEDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_CHARADDED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_CHARADDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_SAVEPOINTREACHED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_SAVEPOINTREACHED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_SAVEPOINTLEFT(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_SAVEPOINTLEFT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_ROMODIFYATTEMPT(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_ROMODIFYATTEMPT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_KEY(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_KEY, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_DOUBLECLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DOUBLECLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_UPDATEUI(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_UPDATEUI, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_MODIFIED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_MODIFIED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_MACRORECORD(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_MACRORECORD, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_MARGINCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_MARGINCLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_NEEDSHOWN(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_NEEDSHOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_POSCHANGED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_POSCHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_PAINTED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_PAINTED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_USERLISTSELECTION(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_USERLISTSELECTION, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_URIDROPPED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_URIDROPPED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_DWELLSTART(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DWELLSTART, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_DWELLEND(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DWELLEND, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_START_DRAG(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_START_DRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_DRAG_OVER(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DRAG_OVER, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_DO_DROP(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DO_DROP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_ZOOM(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_ZOOM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_HOTSPOT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_HOTSPOT_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_HOTSPOT_DCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_HOTSPOT_DCLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_CALLTIP_CLICK(id, fn)) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_CALLTIP_CLICK id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#define EVT_SCI_AUTOCOMP_SELECTION(id, fn)) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_AUTOCOMP_SELECTION id, -1, (wxObjectEventFunction) (wxEventFunction) (wxScintillaEventFunction) & fn, (wxObject *) NULL), +#else +#define EVT_SCI_CHANGE(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_CHANGE, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_STYLENEEDED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_STYLENEEDED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_CHARADDED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_CHARADDED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_SAVEPOINTREACHED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_SAVEPOINTREACHED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_SAVEPOINTLEFT(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_SAVEPOINTLEFT, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_ROMODIFYATTEMPT(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_ROMODIFYATTEMPT, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_KEY(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_KEY, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_DOUBLECLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DOUBLECLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_UPDATEUI(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_UPDATEUI, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_MODIFIED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_MODIFIED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_MACRORECORD(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_MACRORECORD, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_MARGINCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_MARGINCLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_NEEDSHOWN(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_NEEDSHOWN, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_PAINTED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_PAINTED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_USERLISTSELECTION(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_USERLISTSELECTION, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_URIDROPPED(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_URIDROPPED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_DWELLSTART(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DWELLSTART, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_DWELLEND(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DWELLEND, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_START_DRAG(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_START_DRAG, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_DRAG_OVER(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DRAG_OVER, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_DO_DROP(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_DO_DROP, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_ZOOM(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_ZOOM, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_HOTSPOT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_HOTSPOT_CLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_HOTSPOT_DCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_HOTSPOT_DCLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_CALLTIP_CLICK(id, fn)) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_CALLTIP_CLICK id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#define EVT_SCI_AUTOCOMP_SELECTION(id, fn)) DECLARE_EVENT_TABLE_ENTRY (wxEVT_SCI_AUTOCOMP_SELECTION id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxScintillaEventFunction, & fn ), (wxObject *) NULL), +#endif + +#endif + +//---------------------------------------------------------------------- +// Utility functions used within wxScintilla + +#ifndef SWIG + +inline wxString sci2wx (const char* str) { +#if wxUSE_UNICODE + return wxString (str, wxConvUTF8); +#else + return wxString (str); +#endif +} + +#if wxUSE_UNICODE +wxString sci2wx (const char* str, size_t len); +#else +inline wxString sci2wx (const char* str, size_t len) { + return wxString (str, len); +} +#endif + + +#if wxUSE_UNICODE +inline const wxWX2MBbuf wx2sci (const wxString& str) { + return str.mb_str (wxConvUTF8); +} +#else +inline const wxWX2MBbuf wx2sci (const wxString& str) { + return str.mbc_str(); +} +#endif + +#endif + + +//---------------------------------------------------------------------- +#endif // __WXSCINTILLA_H__ diff --git a/sdk/wxscintilla/src/PlatWX.cpp b/sdk/wxscintilla/src/PlatWX.cpp new file mode 100644 index 0000000..e28b6a3 --- /dev/null +++ b/sdk/wxscintilla/src/PlatWX.cpp @@ -0,0 +1,1647 @@ +// Scintilla source code edit control +// PlatWX.cxx - implementation of platform facilities on wxWidgets +// Copyright 1998-1999 by Neil Hodgson +// Robin Dunn +// The License.txt file describes the conditions under which this software may be distributed. + +#include + +#include +#include +#include +#include +#include +#include +#include +#ifdef wxHAVE_RAW_BITMAP +#include +#endif + +#include "Platform.h" +#include "PlatWX.h" +#include "wx/wxscintilla.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +namespace Scintilla +{ +#endif + +Point Point::FromLong(long lpoint) +{ + return Point(lpoint & 0xFFFF, lpoint >> 16); +} + +wxRect wxRectFromPRectangle(PRectangle prc) +{ + wxRect r(prc.left, prc.top, + prc.Width(), prc.Height()); + return r; +} + +PRectangle PRectangleFromwxRect(wxRect rc) +{ + return PRectangle(rc.GetLeft(), rc.GetTop(), + rc.GetRight()+1, rc.GetBottom()+1); +} + +wxColour wxColourFromCA(const ColourAllocated& ca) +{ + ColourDesired cd(ca.AsLong()); + return wxColour((unsigned char)cd.GetRed(), + (unsigned char)cd.GetGreen(), + (unsigned char)cd.GetBlue()); +} + +//---------------------------------------------------------------------- + +Palette::Palette() +{ + used = 0; + allowRealization = false; + size = 100; + entries = new ColourPair[size]; +} + +Palette::~Palette() +{ + Release(); + delete []entries; + entries = 0; +} + +void Palette::Release() +{ + used = 0; + delete []entries; + size = 100; + entries = new ColourPair[size]; +} + +// This method either adds a colour to the list of wanted colours (want==true) +// or retrieves the allocated colour back to the ColourPair. +// This is one method to make it easier to keep the code for wanting and retrieving in sync. +void Palette::WantFind(ColourPair &cp, bool want) +{ + if (want) { + for (int i=0; i < used; i++) { + if (entries[i].desired == cp.desired) + return; + } + + if (used >= size) { + int sizeNew = size * 2; + ColourPair *entriesNew = new ColourPair[sizeNew]; + for (int j=0; jSetNoAntiAliasing (!extraFontFlag); + fid = font; +} + + +void Font::Release() +{ + if (fid) + delete (wxFont*)fid; + fid = 0; +} + +//---------------------------------------------------------------------- +class SurfaceImpl : public Surface +{ +private: + wxDC* hdc; + bool hdcOwned; + wxBitmap* bitmap; + int x; + int y; + bool unicodeMode; + +public: + SurfaceImpl(); + ~SurfaceImpl(); + + virtual void Init(WindowID wid); + virtual void Init(SurfaceID sid, WindowID wid); + virtual void InitPixMap(int width, int height, Surface *surface_, WindowID wid); + + virtual void Release(); + virtual bool Initialised(); + virtual void PenColour(ColourAllocated fore); + virtual int LogPixelsY(); + virtual int DeviceHeightFont(int points); + virtual void MoveTo(int x_, int y_); + virtual void LineTo(int x_, int y_); + virtual void Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back); + virtual void RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back); + virtual void FillRectangle(PRectangle rc, ColourAllocated back); + virtual void FillRectangle(PRectangle rc, Surface &surfacePattern); + virtual void RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back); + virtual void AlphaRectangle(PRectangle rc, int cornerSize, ColourAllocated fill, int alphaFill, ColourAllocated outline, int alphaOutline, int flags); + virtual void Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back); + virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource); + + virtual void DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back); + virtual void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back); + virtual void DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore); + virtual void MeasureWidths(Font &font_, const char *s, int len, int *positions); + virtual int WidthText(Font &font_, const char *s, int len); + virtual int WidthChar(Font &font_, char ch); + virtual int Ascent(Font &font_); + virtual int Descent(Font &font_); + virtual int InternalLeading(Font &font_); + virtual int ExternalLeading(Font &font_); + virtual int Height(Font &font_); + virtual int AverageCharWidth(Font &font_); + + virtual int SetPalette(Palette *pal, bool inBackGround); + virtual void SetClip(PRectangle rc); + virtual void FlushCachedState(); + + virtual void SetUnicodeMode(bool unicodeMode_); + virtual void SetDBCSMode(int codePage); + + void BrushColour(ColourAllocated back); + void SetFont(Font &font_); +}; + +SurfaceImpl::SurfaceImpl() : + hdc(0), hdcOwned(0), bitmap(0), + x(0), y(0), unicodeMode(0) +{} + +SurfaceImpl::~SurfaceImpl() +{ + Release(); +} + +void SurfaceImpl::Init(WindowID wid) +{ +#if 0 + Release(); + hdc = new wxMemoryDC(); + hdcOwned = true; +#else + // On Mac and GTK the DC is not really valid until it has a bitmap + // selected into it. So instead of just creating the DC with no bitmap, + // go ahead and give it one. + InitPixMap(1,1,NULL,wid); +#endif +} + +void SurfaceImpl::Init(SurfaceID hdc_, WindowID) +{ + Release(); + hdc = (wxDC*)hdc_; +} + +void SurfaceImpl::InitPixMap(int width, int height, Surface *WXUNUSED(surface_), WindowID) +{ + Release(); + hdc = new wxMemoryDC(); + hdcOwned = true; + if (width < 1) width = 1; + if (height < 1) height = 1; + bitmap = new wxBitmap(width, height); + ((wxMemoryDC*)hdc)->SelectObject(*bitmap); +} + + +void SurfaceImpl::Release() +{ + if (bitmap) { + ((wxMemoryDC*)hdc)->SelectObject(wxNullBitmap); + delete bitmap; + bitmap = 0; + } + if (hdcOwned) { + delete hdc; + hdc = 0; + hdcOwned = false; + } +} + + +bool SurfaceImpl::Initialised() +{ + return hdc != 0; +} + + +void SurfaceImpl::PenColour(ColourAllocated fore) +{ + if( fore.AsLong() == -1 ) { + hdc->SetPen( *wxTRANSPARENT_PEN ); + } else { + hdc->SetPen(wxPen(wxColourFromCA(fore), 1, wxSOLID)); + } +} + +void SurfaceImpl::BrushColour(ColourAllocated back) +{ + if( back.AsLong() == -1 ) { + hdc->SetBrush( *wxTRANSPARENT_BRUSH ); + } else { + hdc->SetBrush(wxBrush(wxColourFromCA(back), wxSOLID)); + } +} + +void SurfaceImpl::SetFont(Font &font_) +{ + if (font_.GetID()) { + hdc->SetFont(*((wxFont*)font_.GetID())); + } +} + +int SurfaceImpl::LogPixelsY() +{ + return hdc->GetPPI().y; +} + +int SurfaceImpl::DeviceHeightFont(int points) +{ + return points; +} + +void SurfaceImpl::MoveTo(int x_, int y_) +{ + x = x_; + y = y_; +} + +void SurfaceImpl::LineTo(int x_, int y_) +{ + hdc->DrawLine(x,y, x_,y_); + x = x_; + y = y_; +} + +void SurfaceImpl::Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back) +{ + PenColour(fore); + BrushColour(back); + hdc->DrawPolygon(npts, (wxPoint*)pts); +} + +void SurfaceImpl::RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back) +{ + PenColour(fore); + BrushColour(back); + hdc->DrawRectangle(wxRectFromPRectangle(rc)); +} + +void SurfaceImpl::FillRectangle(PRectangle rc, ColourAllocated back) +{ + BrushColour(back); + hdc->SetPen(*wxTRANSPARENT_PEN); + hdc->DrawRectangle(wxRectFromPRectangle(rc)); +} + +void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern) +{ + wxBrush br; + if (((SurfaceImpl&)surfacePattern).bitmap) + br = wxBrush(*((SurfaceImpl&)surfacePattern).bitmap); + else // Something is wrong so display in red + br = wxBrush(*wxRED, wxSOLID); + hdc->SetPen(*wxTRANSPARENT_PEN); + hdc->SetBrush(br); + hdc->DrawRectangle(wxRectFromPRectangle(rc)); +} + +void SurfaceImpl::RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back) +{ + PenColour(fore); + BrushColour(back); + wxRect rr = wxRectFromPRectangle(rc); + hdc->DrawRoundedRectangle(rr, 1); +} + +void SurfaceImpl::AlphaRectangle (PRectangle rc, int cornerSize, ColourAllocated fill, int alphaFill, ColourAllocated outline, int alphaOutline, int WXUNUSED(flags)) +{ + +#ifdef wxHAVE_RAW_BITMAP + int x, y; + wxRect r = wxRectFromPRectangle(rc); + wxRect outlineRect (r); + + wxBitmap bmp(r.width, r.height, 32); + if(bmp.IsOk() == false) + return; + wxAlphaPixelData pixData(bmp); + pixData.UseAlpha(); + wxAlphaPixelData::Iterator p(pixData); + + // Set the fill pixels + ColourDesired cdf(fill.AsLong()); + int red = cdf.GetRed(); + int green = cdf.GetGreen(); + int blue = cdf.GetBlue(); +#ifdef __WXMSW__ + int aFill = alphaFill; +#else + int aFill = 0xff; +#endif + for (y=0; yDrawBitmap(bmp, r.x, r.y, true); + + // ERAN [START] + if (cornerSize) { + // Draw outline rounded-rectangle incase we got a cornerSizer > 0 + hdc->SetBrush(*wxTRANSPARENT_BRUSH); + hdc->SetPen(wxColour(cdo.GetRed(), cdo.GetGreen(), cdo.GetBlue())); +#ifdef __WXGTK__ + cornerSize = 0; +#endif + hdc->DrawRoundedRectangle(outlineRect, cornerSize); + } + // ERAN [END] +#else + wxUnusedVar(cornerSize); + wxUnusedVar(alphaFill); + wxUnusedVar(alphaOutline); + RoundedRectangle(rc, outline, fill); +#endif +} + +void SurfaceImpl::Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back) +{ + PenColour(fore); + BrushColour(back); + hdc->DrawEllipse(wxRectFromPRectangle(rc)); +} + +void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) +{ + wxRect r = wxRectFromPRectangle(rc); + hdc->Blit(r.x, r.y, r.width, r.height, + ((SurfaceImpl&)surfaceSource).hdc, + from.x, from.y, wxCOPY); +} + +void SurfaceImpl::DrawTextNoClip(PRectangle rc, Font &font, int ybase, + const char *s, int len, + ColourAllocated fore, ColourAllocated back) +{ + SetFont(font); + hdc->SetTextForeground(wxColourFromCA(fore)); + hdc->SetTextBackground(wxColourFromCA(back)); + FillRectangle(rc, back); + + // ybase is where the baseline should be, but wxWin uses the upper left + // corner, so I need to calculate the real position for the text... + hdc->DrawText(sci2wx(s, len), rc.left, ybase - font.ascent); +} + +void SurfaceImpl::DrawTextClipped(PRectangle rc, Font &font, int ybase, + const char *s, int len, + ColourAllocated fore, ColourAllocated back) +{ + SetFont(font); + hdc->SetTextForeground(wxColourFromCA(fore)); + hdc->SetTextBackground(wxColourFromCA(back)); + FillRectangle(rc, back); + hdc->SetClippingRegion(wxRectFromPRectangle(rc)); + + // see comments above + hdc->DrawText(sci2wx(s, len), rc.left, ybase - font.ascent); + hdc->DestroyClippingRegion(); +} + + +void SurfaceImpl::DrawTextTransparent(PRectangle rc, Font &font, int ybase, + const char *s, int len, + ColourAllocated fore) +{ + + SetFont(font); + hdc->SetTextForeground(wxColourFromCA(fore)); + hdc->SetBackgroundMode(wxTRANSPARENT); + + // ybase is where the baseline should be, but wxWin uses the upper left + // corner, so I need to calculate the real position for the text... + hdc->DrawText(sci2wx(s, len), rc.left, ybase - font.ascent); + + hdc->SetBackgroundMode(wxSOLID); +} + + +void SurfaceImpl::MeasureWidths(Font &font, const char *s, int len, int *positions) +{ + + wxString str = sci2wx(s, len); + SetFont(font); + +#if !wxCHECK_VERSION(2, 5, 0) +#ifndef __WXMAC__ + // Calculate the position of each character based on the widths of + // the previous characters + int* tpos = new int[len+1]; + int totalWidth = 0; + size_t i; + for (i=0; iGetTextExtent(str[i], &w, &h); + totalWidth += w; + tpos[i] = totalWidth; + } +#else + // Instead of a running total, remeasure from the begining of the + // text for each character's position. This is because with AA fonts + // on OS X widths can be fractions of pixels wide when more than one + // are drawn together, so the sum of all character widths is not necessarily + // (and probably not) the same as the whole string width. + int* tpos = new int[len+1]; + size_t i; + for (i=0; iGetTextExtent(str.Left(i+1), &w, &h); + tpos[i] = w; + } +#endif +#else + wxArrayInt tpos; + hdc->GetPartialTextExtents(str, tpos); +#endif + + +#if wxUSE_UNICODE + // Map the widths for UCS-2 characters back to the UTF-8 input string + // NOTE: I don't think this is right for when sizeof(wxChar) > 2, ie wxGTK2 + // so figure it out and fix it! + int j = 0; + size_t ui = 0; + while ((int)j < len) { + unsigned char uch = (unsigned char)s[j]; + positions[j++] = tpos[ui]; + if (uch >= 0x80) { + if (uch < (0x80 + 0x40 + 0x20)) { + positions[j++] = tpos[ui]; + } else { + positions[j++] = tpos[ui]; + positions[j++] = tpos[ui]; + } + } + ui++; + } +#else + + // If not unicode then just use the widths we have +#if !wxCHECK_VERSION(2, 5, 0) + memcpy(positions, tpos, len * sizeof(*tpos)); +#else +#if wxUSE_STL + std::copy(tpos.begin(), tpos.end(), positions); +#else + memcpy(positions, tpos.begin(), len * sizeof(int)); +#endif +#endif +#endif + +#if !wxCHECK_VERSION(2, 5, 0) + delete [] tpos; +#endif +} + + +int SurfaceImpl::WidthText(Font &font, const char *s, int len) +{ + SetFont(font); + int w; + int h; + + hdc->GetTextExtent(sci2wx(s, len), &w, &h); + return w; +} + + +int SurfaceImpl::WidthChar(Font &font, char ch) +{ + SetFont(font); + int w; + int h; + char s[2] = { ch, 0 }; + + hdc->GetTextExtent(sci2wx(s, 1), &w, &h); + return w; +} + +#define EXTENT_TEST wxT(" `~!@#$%^&*()-_=+\\|[]{};:\"\'<,>.?/1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") + +int SurfaceImpl::Ascent(Font &font) +{ + SetFont(font); + int w, h, d, e; + hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e); + font.ascent = h - d; + return font.ascent; +} + +int SurfaceImpl::Descent(Font &font) +{ + SetFont(font); + int w, h, d, e; + hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e); + return d; +} + +int SurfaceImpl::InternalLeading(Font &WXUNUSED(font)) +{ + return 0; +} + +int SurfaceImpl::ExternalLeading(Font &font) +{ + SetFont(font); + int w, h, d, e; + hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e); + return e; +} + +int SurfaceImpl::Height(Font &font) +{ + SetFont(font); + return hdc->GetCharHeight() + 1; +} + +int SurfaceImpl::AverageCharWidth(Font &font) +{ + SetFont(font); + return hdc->GetCharWidth(); +} + +int SurfaceImpl::SetPalette(Palette *WXUNUSED(pal), bool WXUNUSED(inBackGround)) +{ + return 0; +} + +void SurfaceImpl::SetClip(PRectangle rc) +{ + hdc->SetClippingRegion(wxRectFromPRectangle(rc)); +} + +void SurfaceImpl::FlushCachedState() +{ +} + +void SurfaceImpl::SetUnicodeMode(bool unicodeMode_) +{ + unicodeMode=unicodeMode_; +} + +void SurfaceImpl::SetDBCSMode(int WXUNUSED(codePage)) +{ + // dbcsMode = codePage == SC_CP_DBCS; +} + + +Surface *Surface::Allocate() +{ + return new SurfaceImpl; +} + + +//---------------------------------------------------------------------- + + +inline wxWindow* GETWIN(WindowID id) +{ + return (wxWindow*)id; +} + +Window::~Window() +{ +} + +void Window::Destroy() +{ + if (wid) { + Show(false); + GETWIN(wid)->Destroy(); + } + wid = 0; +} + +bool Window::HasFocus() +{ + return wxWindow::FindFocus() == GETWIN(wid); +} + +PRectangle Window::GetPosition() +{ + if (! wid) return PRectangle(); + wxRect rc(GETWIN(wid)->GetPosition(), GETWIN(wid)->GetSize()); + return PRectangleFromwxRect(rc); +} + +void Window::SetPosition(PRectangle rc) +{ + wxRect r = wxRectFromPRectangle(rc); + GETWIN(wid)->SetSize(r); +} + +void Window::SetPositionRelative(PRectangle rc, Window) +{ + SetPosition(rc); // ???? +} + +PRectangle Window::GetClientPosition() +{ + if (! wid) return PRectangle(); + wxSize sz = GETWIN(wid)->GetClientSize(); + return PRectangle(0, 0, sz.x, sz.y); +} + +void Window::Show(bool show) +{ + GETWIN(wid)->Show(show); +} + +void Window::InvalidateAll() +{ + GETWIN(wid)->Refresh(false); +} + +void Window::InvalidateRectangle(PRectangle rc) +{ + wxRect r = wxRectFromPRectangle(rc); + GETWIN(wid)->Refresh(false, &r); +} + +void Window::SetFont(Font &font) +{ + GETWIN(wid)->SetFont(*((wxFont*)font.GetID())); +} + +void Window::SetCursor(Cursor curs) +{ + int cursorId; + + switch (curs) { + case cursorText: + cursorId = wxCURSOR_IBEAM; + break; + case cursorArrow: + cursorId = wxCURSOR_ARROW; + break; + case cursorUp: + cursorId = wxCURSOR_ARROW; // ** no up arrow... wxCURSOR_UPARROW; + break; + case cursorWait: + cursorId = wxCURSOR_WAIT; + break; + case cursorHoriz: + cursorId = wxCURSOR_SIZEWE; + break; + case cursorVert: + cursorId = wxCURSOR_SIZENS; + break; + case cursorReverseArrow: + //ERAN - BEGIN + cursorId = wxCURSOR_ARROW; + //END - END + break; + case cursorHand: + cursorId = wxCURSOR_HAND; + break; + default: + cursorId = wxCURSOR_ARROW; + break; + } +#ifdef __WXMOTIF__ + wxCursor wc = wxStockCursor(cursorId) ; +#else + wxCursor wc = wxCursor(cursorId) ; +#endif + if (curs != cursorLast) { + GETWIN(wid)->SetCursor(wc); + cursorLast = curs; + } +} + + +void Window::SetTitle (const char *s) +{ + GETWIN(wid)->SetLabel (sci2wx(s)); +} + +PRectangle Window::GetMonitorRect(Point pt) +{ + return PRectangle(); +} + +#ifdef SCI_NAMESPACE +} +#endif + +//---------------------------------------------------------------------- +// Helper classes for ListBox + + +// This is a simple subclass of wxListView that just resets focus to the +// parent when it gets it. +class wxSCIListBox : public wxListView +{ +public: + wxSCIListBox (wxWindow* parent, wxWindowID id, + const wxPoint& pos, const wxSize& size, + long style) : wxListView() { +#ifdef __WXMSW__ + Hide(); // don't flicker as we move it around... +#endif + Create(parent, id, pos, size, style); + } + + void OnFocus(wxFocusEvent& event) { + GetParent()->SetFocus(); + event.Skip(); + } + + void OnKillFocus(wxFocusEvent& WXUNUSED(event)) { + // Do nothing. Prevents base class from resetting the colors... + } + +#ifdef __WXMAC__ + // For some reason I don't understand yet the focus doesn't really leave + // the listbox like it should, so if we get any events feed them back to + // the wxSintilla + void OnKeyDown(wxKeyEvent& event) { + GetGrandParent()->GetEventHandler()->ProcessEvent(event); + } + void OnChar(wxKeyEvent& event) { + GetGrandParent()->GetEventHandler()->ProcessEvent(event); + } + + // And we need to force the focus back when being destroyed + ~wxSCIListBox() { + GetGrandParent()->SetFocus(); + } +#endif + +private: + DECLARE_EVENT_TABLE() +}; + +BEGIN_EVENT_TABLE(wxSCIListBox, wxListView) + EVT_SET_FOCUS( wxSCIListBox::OnFocus) + EVT_KILL_FOCUS(wxSCIListBox::OnKillFocus) + #ifdef __WXMAC__ + EVT_KEY_DOWN( wxSCIListBox::OnKeyDown) + EVT_CHAR( wxSCIListBox::OnChar) + #endif +END_EVENT_TABLE() + + +#if wxUSE_POPUPWIN //----------------------------------- +#include + +// TODO: Refactor these two classes to have a common base (or a mix-in) to get +// rid of the code duplication. (Either that or convince somebody to +// implement wxPopupWindow for the Mac!!) +// +// In the meantime, be careful to duplicate any changes as needed... + +// A popup window to place the wxSCIListBox upon +class wxSCIListBoxWin : public wxPopupWindow +{ +private: + wxListView* lv; + CallBackAction doubleClickAction; + void* doubleClickActionData; +public: + wxSCIListBoxWin(wxWindow* parent, wxWindowID id, Point WXUNUSED(location)) : + wxPopupWindow(parent, wxBORDER_NONE) { + SetBackgroundColour(*wxBLACK); // for our simple border + + lv = new wxSCIListBox(parent, id, wxDefaultPosition, wxDefaultSize, + wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxBORDER_NONE); + lv->SetCursor(wxCursor(wxCURSOR_ARROW)); + lv->InsertColumn(0, wxEmptyString); + lv->InsertColumn(1, wxEmptyString); + + // NOTE: We need to fool the wxListView into thinking that it has the + // focus so it will use the normal selection colour and will look + // "right" to the user. But since the wxPopupWindow or its children + // can't receive focus then we have to pull a fast one and temporarily + // parent the listctrl on the STC window and then call SetFocus and + // then reparent it back to the popup. + lv->SetFocus(); + lv->Reparent(this); +#ifdef __WXMSW__ + lv->Show(); +#endif + } + + + // Set position in client coords + virtual void DoSetSize(int x, int y, + int width, int height, + int sizeFlags = wxSIZE_AUTO) { +#if !wxCHECK_VERSION(2, 5, 0) + if (x != -1) { +#else + if (x != wxDefaultCoord) { +#endif + GetParent()->ClientToScreen(&x, NULL); + } +#if !wxCHECK_VERSION(2, 5, 0) + if (y != -1) { +#else + if (y != wxDefaultCoord) { +#endif + GetParent()->ClientToScreen(NULL, &y); + } + wxPopupWindow::DoSetSize(x, y, width, height, sizeFlags); + } + + // return position as if it were in client coords + virtual void DoGetPosition( int *x, int *y ) const { + int sx, sy; + wxPopupWindow::DoGetPosition(&sx, &sy); + GetParent()->ScreenToClient(&sx, &sy); + if (x) *x = sx; + if (y) *y = sy; + } + + + bool Destroy() { + if ( !wxPendingDelete.Member(this) ) + wxPendingDelete.Append(this); + return true; + } + + + int IconWidth() { + wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL); + if (il != NULL) { + int w, h; + il->GetSize(0, w, h); + return w; + } + return 0; + } + + + void SetDoubleClickAction(CallBackAction action, void *data) { + doubleClickAction = action; + doubleClickActionData = data; + } + + + void OnFocus(wxFocusEvent& event) { + GetParent()->SetFocus(); + event.Skip(); + } + + void OnSize(wxSizeEvent& event) { + // resize the child + wxSize sz = GetSize(); + sz.x -= 2; + sz.y -= 2; + lv->SetSize(1, 1, sz.x, sz.y); + // reset the column widths + lv->SetColumnWidth(0, IconWidth()+4); + lv->SetColumnWidth(1, sz.x - 2 - lv->GetColumnWidth(0) - + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X)); + event.Skip(); + } + + void OnActivate(wxListEvent& WXUNUSED(event)) { + doubleClickAction(doubleClickActionData); + } + + wxListView* GetLB() { + return lv; + } + +private: + DECLARE_EVENT_TABLE() + +}; + +BEGIN_EVENT_TABLE(wxSCIListBoxWin, wxPopupWindow) + EVT_SET_FOCUS ( wxSCIListBoxWin::OnFocus) + EVT_SIZE ( wxSCIListBoxWin::OnSize) + EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxSCIListBoxWin::OnActivate) +END_EVENT_TABLE() + +#else // wxUSE_POPUPWIN ----------------------------------- + +// A normal window to place the wxSCIListBox upon. +class wxSCIListBoxWin : public wxWindow +{ +private: + wxListView* lv; + CallBackAction doubleClickAction; + void* doubleClickActionData; +public: + wxSCIListBoxWin(wxWindow* parent, wxWindowID id, Point location) : + wxWindow(parent, id, wxPoint(location.x, location.y), wxSize(0,0), wxSIMPLE_BORDER) { + + lv = new wxSCIListBox(this, id, wxDefaultPosition, wxDefaultSize, + wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxNO_BORDER); + lv->SetCursor(wxCursor(wxCURSOR_ARROW)); + lv->InsertColumn(0, wxEmptyString); + lv->InsertColumn(1, wxEmptyString); + + // Eventhough we immediately reset the focus to the parent, this helps + // things to look right... + lv->SetFocus(); + + Hide(); + } + + + // On OSX and (possibly others) there can still be pending + // messages/events for the list control when Scintilla wants to + // close it, so do a pending delete of it instead of destroying + // immediately. + bool Destroy() { +#ifdef __WXMAC__ + // The bottom edge of this window is not getting properly + // refreshed upon deletion, so help it out... + wxWindow* p = GetParent(); + wxRect r(GetPosition(), GetSize()); + r.SetHeight(r.GetHeight()+1); + p->Refresh(false, &r); +#endif + if ( !wxPendingDelete.Member(this) ) + wxPendingDelete.Append(this); + return true; + } + + + int IconWidth() { + wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL); + if (il != NULL) { + int w, h; + il->GetSize(0, w, h); + return w; + } + return 0; + } + + + void SetDoubleClickAction(CallBackAction action, void *data) { + doubleClickAction = action; + doubleClickActionData = data; + } + + + void OnFocus(wxFocusEvent& event) { + GetParent()->SetFocus(); + event.Skip(); + } + + void OnSize(wxSizeEvent& event) { + // resize the child + wxSize sz = GetClientSize(); + lv->SetSize(sz); + // reset the column widths + lv->SetColumnWidth(0, IconWidth()+4); + lv->SetColumnWidth(1, sz.x - 2 - lv->GetColumnWidth(0) - + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X)); + event.Skip(); + } + +#ifdef __WXMAC__ + virtual bool Show(bool show = true) { + bool rv = wxWindow::Show(show); + GetParent()->Refresh(false); + return rv; + } +#endif + + void OnActivate(wxListEvent& WXUNUSED(event)) { + doubleClickAction(doubleClickActionData); + } + + wxListView* GetLB() { + return lv; + } + +private: + DECLARE_EVENT_TABLE() +}; + + +BEGIN_EVENT_TABLE(wxSCIListBoxWin, wxWindow) + EVT_SET_FOCUS ( wxSCIListBoxWin::OnFocus) + EVT_SIZE ( wxSCIListBoxWin::OnSize) + EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxSCIListBoxWin::OnActivate) +END_EVENT_TABLE() + +#endif // wxUSE_POPUPWIN ----------------------------------- + +inline wxSCIListBoxWin* GETLBW(WindowID win) { + return ((wxSCIListBoxWin*)win); +} + +inline wxListView* GETLB(WindowID win) { + return GETLBW(win)->GetLB(); +} + +//---------------------------------------------------------------------- + +class ListBoxImpl : public ListBox +{ +private: + int lineHeight; + bool unicodeMode; + int desiredVisibleRows; + int aveCharWidth; + size_t maxStrWidth; + Point location; // Caret location at which the list is opened + wxImageList* imgList; + wxArrayInt* imgTypeMap; + +public: + ListBoxImpl(); + ~ListBoxImpl(); + + virtual void SetFont(Font &font); + virtual void Create(Window &parent, int ctrlID, Point location_, int lineHeight_, bool unicodeMode_); + virtual void SetAverageCharWidth(int width); + virtual void SetVisibleRows(int rows); + virtual int GetVisibleRows() const; + virtual PRectangle GetDesiredRect(); + virtual int CaretFromEdge(); + virtual void Clear(); + virtual void Append(char *s, int type = -1); + virtual void Append(const wxString& text, int type); + virtual int Length(); + virtual void Select(int n); + virtual int GetSelection(); + virtual int Find(const char *prefix); + virtual void GetValue(int n, char *value, int len); + virtual void RegisterImage(int type, const char *xpm_data); + virtual void ClearRegisteredImages(); + virtual void SetDoubleClickAction(CallBackAction, void *); + virtual void SetList(const char* list, char separator, char typesep); +}; + + +ListBoxImpl::ListBoxImpl() + : lineHeight(10), unicodeMode(false), + desiredVisibleRows(5), aveCharWidth(8), maxStrWidth(0), + imgList(NULL), imgTypeMap(NULL) { +} + +ListBoxImpl::~ListBoxImpl() { + if (imgList) { + delete imgList; + imgList = NULL; + } + if (imgTypeMap) { + delete imgTypeMap; + imgTypeMap = NULL; + } +} + + +void ListBoxImpl::SetFont(Font &font) { + GETLB(wid)->SetFont(*((wxFont*)font.GetID())); +} + + +void ListBoxImpl::Create (Window &parent, int ctrlID, Point location_, + int lineHeight_, bool unicodeMode_) { + lineHeight = lineHeight_; + unicodeMode = unicodeMode_; + maxStrWidth = 0; + wid = new wxSCIListBoxWin (GETWIN(parent.GetID()), ctrlID, location_); + if (imgList != NULL) GETLB(wid)->SetImageList (imgList, wxIMAGE_LIST_SMALL); +} + + +void ListBoxImpl::SetAverageCharWidth(int width) { + aveCharWidth = width; +} + + +void ListBoxImpl::SetVisibleRows(int rows) { + desiredVisibleRows = rows; +} + + +int ListBoxImpl::GetVisibleRows() const { + return desiredVisibleRows; +} + + +PRectangle ListBoxImpl::GetDesiredRect() { + // wxListCtrl doesn't have a DoGetBestSize, so instead we kept track of + // the max size in Append and calculate it here... + int maxw = maxStrWidth * aveCharWidth; + int maxh ; + + // give it a default if there are no lines, and/or add a bit more + if (maxw == 0) maxw = 100; + maxw += aveCharWidth * 3 + + GETLBW(wid)->IconWidth() + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X); + if (maxw > 600) + maxw = 600; + + // estimate a desired height + int count = GETLB(wid)->GetItemCount(); + if (count) { + wxRect rect; + GETLB(wid)->GetItemRect(0, rect); + maxh = count * rect.GetHeight(); + if (maxh > 140) // TODO: Use desiredVisibleRows?? + maxh = 140; + + // Try to make the size an exact multiple of some number of lines + int lines = maxh / rect.GetHeight(); + maxh = (lines + 1) * rect.GetHeight() + 2; + } else + maxh = 100; + + PRectangle rc; + rc.top = 0; + rc.left = 0; + rc.right = maxw; + rc.bottom = maxh; + return rc; +} + + +int ListBoxImpl::CaretFromEdge() { + return 4 + GETLBW(wid)->IconWidth(); +} + + +void ListBoxImpl::Clear() { + GETLB(wid)->DeleteAllItems(); +} + + +void ListBoxImpl::Append(char *s, int type) { + Append(sci2wx(s), type); +} +void ListBoxImpl::Append(const wxString& text, int type) { + long count = GETLB(wid)->GetItemCount(); + long itemID = GETLB(wid)->InsertItem(count, wxEmptyString); + GETLB(wid)->SetItem(itemID, 1, text); + maxStrWidth = wxMax(maxStrWidth, text.length()); + if (type != -1) { + wxCHECK_RET(imgTypeMap, wxT("Unexpected NULL imgTypeMap")); + long idx = imgTypeMap->Item(type); + GETLB(wid)->SetItemImage(itemID, idx, idx); + } +} + + +int ListBoxImpl::Length() { + return GETLB(wid)->GetItemCount(); +} + + +void ListBoxImpl::Select(int n) { + bool select = true; + if (n == -1) { + n = 0; + select = false; + } + GETLB(wid)->Focus(n); + GETLB(wid)->Select(n, select); +} + + +int ListBoxImpl::GetSelection() { + return GETLB(wid)->GetFirstSelected(); +} + + +int ListBoxImpl::Find(const char *WXUNUSED(prefix)) { + // No longer used + return wxNOT_FOUND; +} + + +void ListBoxImpl::GetValue(int n, char *value, int len) { + wxListItem item; + item.SetId(n); + item.SetColumn(1); + item.SetMask(wxLIST_MASK_TEXT); + GETLB(wid)->GetItem(item); + strncpy(value, wx2sci(item.GetText()), len); + value[len-1] = '\0'; +} + + +void ListBoxImpl::RegisterImage(int type, const char *xpm_data) { + wxMemoryInputStream stream(xpm_data, strlen(xpm_data)+1); + wxImage img(stream, wxBITMAP_TYPE_XPM); + wxBitmap bmp(img); + + if (! imgList) { + // assumes all images are the same size + imgList = new wxImageList(bmp.GetWidth(), bmp.GetHeight(), true); + imgTypeMap = new wxArrayInt; + } + + int idx = imgList->Add(bmp); + + // do we need to extend the mapping array? + wxArrayInt& itm = *imgTypeMap; + if ( itm.GetCount() < (size_t)type+1) + itm.Add(-1, type - itm.GetCount() + 1); + + // Add an item that maps type to the image index + itm[type] = idx; +} + +void ListBoxImpl::ClearRegisteredImages() { + if (imgList) { + delete imgList; + imgList = NULL; + } + if (imgTypeMap) { + delete imgTypeMap; + imgTypeMap = NULL; + } + if (wid) GETLB(wid)->SetImageList(NULL, wxIMAGE_LIST_SMALL); +} + + +void ListBoxImpl::SetDoubleClickAction(CallBackAction action, void *data) { + GETLBW(wid)->SetDoubleClickAction(action, data); +} + +void ListBoxImpl::SetList(const char* list, char separator, char typesep) { + GETLB(wid)->Freeze(); + Clear(); + wxStringTokenizer tkzr(sci2wx(list), (wxChar)separator); + while (tkzr.HasMoreTokens()) { + wxString token = tkzr.GetNextToken(); + long type = -1; + int pos = token.Find(typesep); + if (pos != -1) { + token.Mid(pos+1).ToLong(&type); + token.Truncate(pos); + } + Append (token, (int)type); + } + GETLB(wid)->Thaw(); +} + + +ListBox::ListBox() { +} + +ListBox::~ListBox() { +} + +ListBox *ListBox::Allocate() { + return new ListBoxImpl(); +} + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +//---------------------------------------------------------------------- + +Menu::Menu() : mid(0) +{ +} + +void Menu::CreatePopUp() +{ + Destroy(); + mid = new wxMenu(); +} + +void Menu::Destroy() +{ + if (mid) + delete (wxMenu*)mid; + mid = 0; +} + +void Menu::Show(Point pt, Window &w) +{ + GETWIN(w.GetID())->PopupMenu((wxMenu*)mid, pt.x - 4, pt.y); + Destroy(); +} + +//---------------------------------------------------------------------- + +DynamicLibrary *DynamicLibrary::Load(const char *WXUNUSED(modulePath)) +{ + wxFAIL_MSG(wxT("Dynamic lexer loading not implemented yet")); + return NULL; +} + +//---------------------------------------------------------------------- + +ColourDesired Platform::Chrome() +{ + wxColour c; + c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE); + return ColourDesired(c.Red(), c.Green(), c.Blue()); +} + +ColourDesired Platform::ChromeHighlight() +{ + wxColour c; + c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT); + return ColourDesired(c.Red(), c.Green(), c.Blue()); +} + +const char *Platform::DefaultFont() +{ + static char buf[128]; + strcpy(buf, wxNORMAL_FONT->GetFaceName().mbc_str()); + return buf; +} + +int Platform::DefaultFontSize() +{ + return wxNORMAL_FONT->GetPointSize(); +} + +unsigned int Platform::DoubleClickTime() +{ + return 500; // **** ::GetDoubleClickTime(); +} + +bool Platform::MouseButtonBounce() +{ + return false; +} +void Platform::DebugDisplay(const char *s) +{ + wxLogDebug(sci2wx(s)); +} + +bool Platform::IsKeyDown(int WXUNUSED(key)) +{ + return false; // I don't think we'll need this. +} + +long Platform::SendScintilla(WindowID w, + unsigned int msg, + unsigned long wParam, + long lParam) +{ + + wxScintilla* sci = (wxScintilla*)w; + return sci->SendMsg(msg, wParam, lParam); +} + +long Platform::SendScintillaPointer(WindowID w, + unsigned int msg, + unsigned long wParam, + void *lParam) +{ + + wxScintilla* sci = (wxScintilla*)w; + return sci->SendMsg(msg, wParam, (long)lParam); +} + + +// These are utility functions not really tied to a platform + +int Platform::Minimum(int a, int b) +{ + if (a < b) + return a; + else + return b; +} + +int Platform::Maximum(int a, int b) +{ + if (a > b) + return a; + else + return b; +} + +#define TRACE + +void Platform::DebugPrintf(const char *format, ...) +{ +#ifdef TRACE + char buffer[2000]; + va_list pArguments; + va_start(pArguments, format); + vsprintf(buffer,format,pArguments); + va_end(pArguments); + Platform::DebugDisplay(buffer); +#endif +} + + +static bool assertionPopUps = true; + +bool Platform::ShowAssertionPopUps(bool assertionPopUps_) +{ + bool ret = assertionPopUps; + assertionPopUps = assertionPopUps_; + return ret; +} + +void Platform::Assert(const char *c, const char *file, int line) +{ + char buffer[2000]; + sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line); + if (assertionPopUps) { + /*int idButton = */ + wxMessageBox(sci2wx(buffer), + wxT("Assertion failure"), + wxICON_HAND | wxOK); +// if (idButton == IDRETRY) { +// ::DebugBreak(); +// } else if (idButton == IDIGNORE) { +// // all OK +// } else { +// abort(); +// } + } else { + strcat(buffer, "\r\n"); + Platform::DebugDisplay(buffer); + abort(); + } +} + + +int Platform::Clamp(int val, int minVal, int maxVal) +{ + if (val > maxVal) + val = maxVal; + if (val < minVal) + val = minVal; + return val; +} + + +bool Platform::IsDBCSLeadByte(int WXUNUSED(codePage), char WXUNUSED(ch)) +{ + return false; +} + +int Platform::DBCSCharLength(int WXUNUSED(codePage), const char *WXUNUSED(s)) +{ + return 1; +} + +int Platform::DBCSCharMaxLength() +{ + return 1; +} + +ElapsedTime::ElapsedTime() +{ + wxLongLong localTime = wxGetLocalTimeMillis(); + littleBit = localTime.GetLo(); + bigBit = localTime.GetHi(); +} + +double ElapsedTime::Duration(bool reset) +{ + wxLongLong prevTime(bigBit, littleBit); + wxLongLong localTime = wxGetLocalTimeMillis(); + if (reset) { + littleBit = localTime.GetLo(); + bigBit = localTime.GetHi(); + } + wxLongLong duration = localTime - prevTime; + double result = duration.ToDouble(); + result /= 1000.0; + return result; +} +#ifdef SCI_NAMESPACE +} // end namespace Scintilla +#endif +//---------------------------------------------------------------------- + +#if wxUSE_UNICODE + +#include "UniConversion.h" + +wxString sci2wx(const char* str, size_t len) { + if (!len) + return wxEmptyString; + + size_t wclen = UCS2Length(str, len); + wxWCharBuffer buffer(wclen+1); + + size_t actualLen = UCS2FromUTF8(str, len, buffer.data(), wclen+1); + return wxString(buffer.data(), actualLen); +} +#endif +//---------------------------------------------------------------------- diff --git a/sdk/wxscintilla/src/PlatWX.h b/sdk/wxscintilla/src/PlatWX.h new file mode 100644 index 0000000..a7c9102 --- /dev/null +++ b/sdk/wxscintilla/src/PlatWX.h @@ -0,0 +1,14 @@ +#ifndef PLATWX_H // [CHANGED] +#define PLATWX_H // [CHANGED] + +#ifdef SCI_NAMESPACE +namespace Scintilla +{ +#endif +wxRect wxRectFromPRectangle(PRectangle prc); +PRectangle PRectangleFromwxRect(wxRect rc); +wxColour wxColourFromCA(const ColourAllocated& ca); +#ifdef SCI_NAMESPACE +} +#endif +#endif // [CHANGED] diff --git a/sdk/wxscintilla/src/ScintillaWX.cpp b/sdk/wxscintilla/src/ScintillaWX.cpp new file mode 100644 index 0000000..599f902 --- /dev/null +++ b/sdk/wxscintilla/src/ScintillaWX.cpp @@ -0,0 +1,1359 @@ +//////////////////////////////////////////////////////////////////////////// +// Name: ScintillaWX.cxx +// Purpose: A wxWidgets implementation of Scintilla. A class derived +// from ScintillaBase that uses the "wx platform" defined in +// PlatformWX.cxx This class is one end of a bridge between +// the wx world and the Scintilla world. It needs a peer +// object of type wxScintilla to function. +// +// Author: Robin Dunn +// +// Created: 13-Jan-2000 +// RCS-ID: $Id: ScintillaWX.cpp,v 1.26 2006/09/22 19:42:14 wyo Exp $ +// Copyright: (c) 2000 by Total Control Software +// Licence: wxWindows license +///////////////////////////////////////////////////////////////////////////// + +#include "ScintillaWX.h" +//?#include "ExternalLexer.h" +#include "PlatWX.h" +#include "wx/wxscintilla.h" +#include +#ifdef __WXMSW__ +#include // GetHwndOf() +#endif + +#ifdef SCI_NAMESPACE // begin [CHANGED] +using namespace Scintilla; +#endif // end [CHANGED] + +//---------------------------------------------------------------------- +// Helper classes + +class wxSCITimer : public wxTimer { +public: + wxSCITimer(ScintillaWX* swx) { + this->swx = swx; + } + + void Notify() { + swx->DoTick(); + } + +private: + ScintillaWX* swx; +}; + + +#if wxUSE_DRAG_AND_DROP +class wxStartDragTimer : public wxTimer { +public: + wxStartDragTimer(ScintillaWX* swx) { + this->swx = swx; + } + + void Notify() { + swx->DoStartDrag(); + } + +private: + ScintillaWX* swx; +}; + +bool wxSCIDropTarget::OnDropText(wxCoord x, wxCoord y, const wxString& data) { + return swx->DoDropText(x, y, data); +} + +wxDragResult wxSCIDropTarget::OnEnter(wxCoord x, wxCoord y, wxDragResult def) { + return swx->DoDragEnter(x, y, def); +} + +wxDragResult wxSCIDropTarget::OnDragOver(wxCoord x, wxCoord y, wxDragResult def) { + return swx->DoDragOver(x, y, def); +} + +void wxSCIDropTarget::OnLeave() { + swx->DoDragLeave(); +} +#endif + + +#if wxUSE_POPUPWIN && wxSCI_USE_POPUP +#include +#define wxSCICallTipBase wxPopupWindow +#define param2 wxBORDER_NONE // popup's 2nd param is flags +#else +#define wxSCICallTipBase wxWindow +#define param2 -1 // wxWindow's 2nd param is ID +#endif + +#include + +class wxSCICallTip : public wxSCICallTipBase { +public: + wxSCICallTip(wxWindow* parent, CallTip* ct, ScintillaWX* swx) + : wxSCICallTipBase(parent, param2), + m_ct(ct), m_swx(swx), m_cx(-1), m_cy(-1) { + } + + ~wxSCICallTip() { +#if wxUSE_POPUPWIN && wxSCI_USE_POPUP && defined(__WXGTK__) + wxRect rect = GetRect(); + rect.x = m_cx; + rect.y = m_cy; + GetParent()->Refresh(false, &rect); +#endif + } + + bool AcceptsFocus() const { + return false; + } + + void OnPaint(wxPaintEvent& WXUNUSED(evt)) { + wxBufferedPaintDC dc(this); + Surface* surfaceWindow = Surface::Allocate(); + surfaceWindow->Init(&dc, m_ct->wDraw.GetID()); + m_ct->PaintCT(surfaceWindow); + surfaceWindow->Release(); + delete surfaceWindow; + } + + void OnFocus(wxFocusEvent& event) { + GetParent()->SetFocus(); + event.Skip(); + } + + void OnLeftDown(wxMouseEvent& event) { + wxPoint pt = event.GetPosition(); + Point p(pt.x, pt.y); + m_ct->MouseClick(p); + m_swx->CallTipClick(); + } + +#if wxUSE_POPUPWIN && wxSCI_USE_POPUP + virtual void DoSetSize(int x, int y, + int width, int height, + int sizeFlags = wxSIZE_AUTO) { + if (x != -1) { + m_cx = x; + GetParent()->ClientToScreen(&x, NULL); + } + if (y != -1) { + m_cy = y; + GetParent()->ClientToScreen(NULL, &y); + } + wxSCICallTipBase::DoSetSize(x, y, width, height, sizeFlags); + } +#endif + + wxPoint GetMyPosition() { + return wxPoint(m_cx, m_cy); + } + +private: + CallTip* m_ct; + ScintillaWX* m_swx; + int m_cx, m_cy; + DECLARE_EVENT_TABLE() +}; + +BEGIN_EVENT_TABLE(wxSCICallTip, wxSCICallTipBase) + EVT_PAINT(wxSCICallTip::OnPaint) + EVT_SET_FOCUS(wxSCICallTip::OnFocus) + EVT_LEFT_DOWN(wxSCICallTip::OnLeftDown) +END_EVENT_TABLE() + + +//---------------------------------------------------------------------- + +#if wxUSE_DATAOBJ +static wxTextFileType wxConvertEOLMode(int scintillaMode) { + wxTextFileType type; + + switch (scintillaMode) { + case wxSCI_EOL_CRLF: + type = wxTextFileType_Dos; + break; + + case wxSCI_EOL_CR: + type = wxTextFileType_Mac; + break; + + case wxSCI_EOL_LF: + type = wxTextFileType_Unix; + break; + + default: + type = wxTextBuffer::typeDefault; + break; + } + return type; +} +#endif // wxUSE_DATAOBJ + + +static int wxCountLines(const char* text, int scintillaMode) { + char eolchar; + + switch (scintillaMode) { + case wxSCI_EOL_CRLF: + case wxSCI_EOL_LF: + eolchar = '\n'; + break; + case wxSCI_EOL_CR: + eolchar = '\r'; + break; + default: + return 0; + } + + int count = 0; + int i = 0; + while (text[i] != 0) { + if (text[i] == eolchar) { + count++; + } + i++; + } + + return count; +} + +//---------------------------------------------------------------------- +// Constructor/Destructor + + +ScintillaWX::ScintillaWX(wxScintilla* win) { + capturedMouse = false; + focusEvent = false; + wMain = win; + sci = win; + wheelRotation = 0; + Initialise(); +#ifdef __WXMSW__ +#if wxCHECK_VERSION(2, 5, 0) + sysCaretBitmap = 0; + sysCaretWidth = 0; + sysCaretHeight = 0; +#endif +#endif +#if wxUSE_DRAG_AND_DROP + startDragTimer = new wxStartDragTimer(this); +#endif +} + + +ScintillaWX::~ScintillaWX() { +#if wxUSE_DRAG_AND_DROP + delete startDragTimer; +#endif + Finalise(); +} + +//---------------------------------------------------------------------- +// base class virtuals + + +void ScintillaWX::Initialise() { + //ScintillaBase::Initialise(); +#if wxUSE_DRAG_AND_DROP + dropTarget = new wxSCIDropTarget; + dropTarget->SetScintilla(this); + sci->SetDropTarget(dropTarget); + dragRectangle = false; +#endif +#ifdef __WXMAC__ + vs.extraFontFlag = false; // UseAntiAliasing +#else + vs.extraFontFlag = true; // UseAntiAliasing +#endif +} + + +void ScintillaWX::Finalise() { + ScintillaBase::Finalise(); + SetTicking(false); + SetIdle(false); + DestroySystemCaret(); +} + + +void ScintillaWX::StartDrag() { +#if wxUSE_DRAG_AND_DROP +#if wxVERSION_NUMBER >= 2800 && defined(__WXGTK__) + // For recent wxGTKs, DnD won't work if we delay with the timer, so go there direct + DoStartDrag(); +#else + startDragTimer->Start (200, true); +#endif // wxVERSION_NUMBER >= 2701 && defined(__WXGTK20__) +#endif +} + +void ScintillaWX::DoStartDrag() { +#if wxUSE_DRAG_AND_DROP + wxString dragText = sci2wx (drag.s, drag.len); + + // Send an event to allow the drag text to be changed + wxScintillaEvent evt(wxEVT_SCI_START_DRAG, sci->GetId()); + evt.SetEventObject (sci); + evt.SetDragText (dragText); + evt.SetDragAllowMove (true); + evt.SetPosition (wxMin(sci->GetSelectionStart(), sci->GetSelectionEnd())); + sci->GetEventHandler()->ProcessEvent (evt); + + pdoc->BeginUndoAction(); + dragText = evt.GetDragText(); + dragRectangle = drag.rectangular; + if (dragText.Length()) { + wxDropSource source(sci); + wxTextDataObject data(dragText); + source.SetData(data); + + inDragDrop = ddDragging; + source.DoDragDrop(wxDrag_DefaultMove); + inDragDrop = ddNone; + SetDragPosition (SelectionPosition(invalidPosition)); + } + pdoc->EndUndoAction(); +#endif +} + + +bool ScintillaWX::SetIdle(bool on) { + if (idler.state != on) { + // connect or disconnect the EVT_IDLE handler + if (on) + sci->Connect(wxID_ANY, wxEVT_IDLE, + (wxObjectEventFunction) (wxEventFunction) (wxIdleEventFunction) &wxScintilla::OnIdle); + else + sci->Disconnect(wxID_ANY, wxEVT_IDLE, + (wxObjectEventFunction) (wxEventFunction) (wxIdleEventFunction) &wxScintilla::OnIdle); + idler.state = on; + } + return idler.state; +} + + +void ScintillaWX::SetTicking(bool on) { + wxSCITimer* stiTimer; + if (timer.ticking != on) { + timer.ticking = on; + if (timer.ticking) { + stiTimer = new wxSCITimer(this); + stiTimer->Start(timer.tickSize); + timer.tickerID = stiTimer; + } else { + stiTimer = (wxSCITimer*)timer.tickerID; + stiTimer->Stop(); + delete stiTimer; + timer.tickerID = 0; + } + } + timer.ticksToWait = caret.period; +} + + +void ScintillaWX::SetMouseCapture(bool on) { + if (mouseDownCaptures) { + if (on && !capturedMouse) + sci->CaptureMouse(); + else if (!on && capturedMouse && sci->HasCapture()) + sci->ReleaseMouse(); + capturedMouse = on; + } +} + + +bool ScintillaWX::HaveMouseCapture() { + return capturedMouse; +} + + +void ScintillaWX::ScrollText(int linesToMove) { + int dy = vs.lineHeight * (linesToMove); + sci->ScrollWindow(0, dy); + sci->Update(); +} + +void ScintillaWX::SetVerticalScrollPos() { + if (sci->m_vScrollBar == NULL) { // Use built-in scrollbar + sci->SetScrollPos(wxVERTICAL, topLine); + } else { // otherwise use the one that's been given to us + sci->m_vScrollBar->SetThumbPosition(topLine); + } +} + +void ScintillaWX::SetHorizontalScrollPos() { + if (sci->m_hScrollBar == NULL) { // Use built-in scrollbar + sci->SetScrollPos(wxHORIZONTAL, xOffset); + } else { // otherwise use the one that's been given to us + sci->m_hScrollBar->SetThumbPosition(xOffset); + } +} + + +const int H_SCROLL_STEP = 20; + +bool ScintillaWX::ModifyScrollBars(int nMax, int nPage) { + bool modified = false; + + int vertEnd = nMax; + if (!verticalScrollBarVisible) + vertEnd = 0; + + // Check the vertical scrollbar + if (sci->m_vScrollBar == NULL) { // Use built-in scrollbar + int sbMax = sci->GetScrollRange(wxVERTICAL); + int sbThumb = sci->GetScrollThumb(wxVERTICAL); + int sbPos = sci->GetScrollPos(wxVERTICAL); + if (sbMax != vertEnd || sbThumb != nPage) { + sci->SetScrollbar(wxVERTICAL, sbPos, nPage, vertEnd+1); + modified = true; + } + } else { // otherwise use the one that's been given to us + int sbMax = sci->m_vScrollBar->GetRange(); + int sbPage = sci->m_vScrollBar->GetPageSize(); + int sbPos = sci->m_vScrollBar->GetThumbPosition(); + if (sbMax != vertEnd || sbPage != nPage) { + sci->m_vScrollBar->SetScrollbar(sbPos, nPage, vertEnd+1, nPage); + modified = true; + } + } + + + // Check the horizontal scrollbar + PRectangle rcText = GetTextRectangle(); + int horizEnd = scrollWidth; + if (horizEnd < 0) + horizEnd = 0; + if (!horizontalScrollBarVisible || (wrapState != eWrapNone)) + horizEnd = 0; + int pageWidth = rcText.Width(); + + if (sci->m_hScrollBar == NULL) { // Use built-in scrollbar + int sbMax = sci->GetScrollRange(wxHORIZONTAL); + int sbThumb = sci->GetScrollThumb(wxHORIZONTAL); + int sbPos = sci->GetScrollPos(wxHORIZONTAL); + if ((sbMax != horizEnd) || (sbThumb != pageWidth) || (sbPos != 0)) { + sci->SetScrollbar(wxHORIZONTAL, sbPos, pageWidth, horizEnd); + modified = true; + if (scrollWidth < pageWidth) { + HorizontalScrollTo(0); + } + } + } else { // otherwise use the one that's been given to us + int sbMax = sci->m_hScrollBar->GetRange(); + int sbThumb = sci->m_hScrollBar->GetPageSize(); + int sbPos = sci->m_hScrollBar->GetThumbPosition(); + if ((sbMax != horizEnd) || (sbThumb != pageWidth) || (sbPos != 0)) { + sci->m_hScrollBar->SetScrollbar(sbPos, pageWidth, horizEnd, pageWidth); + modified = true; + if (scrollWidth < pageWidth) { + HorizontalScrollTo(0); + } + } + } + + return modified; +} + + +void ScintillaWX::NotifyChange() { + sci->NotifyChange(); +} + + +void ScintillaWX::NotifyParent(SCNotification scn) { + sci->NotifyParent(&scn); +} + + +// This method is overloaded from ScintillaBase in order to prevent the +// AutoComplete window from being destroyed when it gets the focus. There is +// a side effect that the AutoComp will also not be destroyed when switching +// to another window, but I think that is okay. +void ScintillaWX::CancelModes() { + if (! focusEvent) + AutoCompleteCancel(); + ct.CallTipCancel(); + Editor::CancelModes(); +} + + +void ScintillaWX::Copy() { + if ( !sel.Empty() ) { + SelectionText st; + CopySelectionRange(&st); +#ifdef __WXGTK__ + for(int i=0; i<5; i++) { + //wxPrintf(wxT("Copying to clipboard %ld\n"), i); + CopyToClipboard(st); + } +#else + CopyToClipboard(st); +#endif + } +} + + +void ScintillaWX::Paste() { + pdoc->BeginUndoAction(); + ClearSelection(); + +#if wxUSE_DATAOBJ + wxTextDataObject data; + wxString textString; + + wxWX2MBbuf buf; + int len = 0; + bool rectangular = false; + + wxTheClipboard->UsePrimarySelection(false); + if (wxTheClipboard->Open()) { + wxCustomDataObject selData(wxDataFormat(wxString(wxT("application/x-cbrectdata")))); + bool gotRectData = wxTheClipboard->GetData(selData); + + if (gotRectData && selData.GetSize()>1) { + const char* rectBuf = (const char*)selData.GetData(); + rectangular = rectBuf[0] == (char)1; + len = selData.GetDataSize()-1; + char* buffer = new char[len]; + memcpy (buffer, rectBuf+1, len); + textString = sci2wx(buffer, len); + delete [] buffer; + } else { + bool gotData = wxTheClipboard->GetData(data); + if (gotData) { + textString = wxTextBuffer::Translate (data.GetText(), + wxConvertEOLMode(pdoc->eolMode)); + } + } + data.SetText(wxEmptyString); // free the data object content + wxTheClipboard->Close(); + } + + // Check to see if the Copy() command inserted a '\r\n' at the begining of the textString + bool allowCopyLines(false); + + buf = (wxWX2MBbuf)wx2sci(textString); + len = strlen(buf); + + // Eran: Allow copy-line to be inserted at the begining of the next line instead + // of at the current caret position + if(len > 0 && buf.data()[len-1] == '\n') { + allowCopyLines = true; + } + + int newPos = 0; + int caretMain = sel.MainCaret(); + if (rectangular) { + SelectionPosition selStart = sel.Range(sel.Main()).Start(); + int newLine = pdoc->LineFromPosition (caretMain) + wxCountLines (buf, pdoc->eolMode); + int newCol = pdoc->GetColumn(caretMain); + PasteRectangular (selStart, buf, len); + newPos = pdoc->FindColumn (newLine, newCol); + } else { + bool allowCopyLineSuccess(false); + if(allowCopyLines) { + // copied text ends with \r\n OR \n + int lineNum = pdoc->LineFromPosition(caretMain); + if(lineNum != wxNOT_FOUND) { + int where = pdoc->LineStart(lineNum); + if(where != wxNOT_FOUND) { + pdoc->InsertString(where, buf, len); + newPos = where + len; + + allowCopyLineSuccess = true; + } + } + } + + if(!allowCopyLineSuccess) { + // Simple copy paste block + pdoc->InsertString (caretMain, buf, len); + newPos = caretMain + len; + } + } + SetEmptySelection (newPos); +#endif // wxUSE_DATAOBJ + + pdoc->EndUndoAction(); + NotifyChange(); + Redraw(); +} + + +void ScintillaWX::CopyToClipboard (const SelectionText& st) { +#if wxUSE_CLIPBOARD + wxTheClipboard->UsePrimarySelection(false); + if (wxTheClipboard->Open()) { + wxString text = wxTextBuffer::Translate (sci2wx(st.s, st.len-1)); + + // composite object will hold "plain text" for pasting in other programs and a custom + // object for local use that remembers what kind of selection was made (stream or + // rectangular). + wxDataObjectComposite* obj = new wxDataObjectComposite(); + wxCustomDataObject* rectData = new wxCustomDataObject (wxDataFormat(wxString(wxT("application/x-cbrectdata")))); + + char* buffer = new char[st.len+1]; + buffer[0] = (st.rectangular)? (char)1 : (char)0; + memcpy (buffer+1, st.s, st.len); + rectData->SetData (st.len+1, buffer); + delete [] buffer; + + obj->Add (rectData, true); + obj->Add (new wxTextDataObject (text)); + wxTheClipboard->SetData (obj); + wxTheClipboard->Close(); + } +#else + wxUnusedVar(st); +#endif // wxUSE_CLIPBOARD +} + + +bool ScintillaWX::CanPaste() { + wxTheClipboard->UsePrimarySelection(false); +#if wxUSE_CLIPBOARD + bool canPaste = false; + bool didOpen; + + if (Editor::CanPaste()) { + didOpen = !wxTheClipboard->IsOpened(); + if ( didOpen ) + wxTheClipboard->Open(); + + if (wxTheClipboard->IsOpened()) { + canPaste = wxTheClipboard->IsSupported(wxUSE_UNICODE ? wxDF_UNICODETEXT : wxDF_TEXT); + if (didOpen) + wxTheClipboard->Close(); + } + } + return canPaste; +#else + return false; +#endif // wxUSE_CLIPBOARD +} + +void ScintillaWX::CreateCallTipWindow(PRectangle) { + if (! ct.wCallTip.Created() ) { + ct.wCallTip = new wxSCICallTip(sci, &ct, this); + ct.wDraw = ct.wCallTip; + } +} + + +void ScintillaWX::AddToPopUp(const char *label, int cmd, bool enabled) { + if (!label[0]) + ((wxMenu*)popup.GetID())->AppendSeparator(); + else + ((wxMenu*)popup.GetID())->Append(cmd, wxGetTranslation(sci2wx(label))); + + if (!enabled) + ((wxMenu*)popup.GetID())->Enable(cmd, enabled); +} + +// [CHANGED] +// This is called by the Editor base class whenever something is selected. +// For wxGTK we can put this text in the primary selection and then other apps +// can paste with the middle button. +void ScintillaWX::ClaimSelection() { + +#if defined(__WXGTK__) && wxCHECK_VERSION(2,9,0) + // Put the selected text in the PRIMARY selection + if (!sel.Empty()) { + SelectionText st; + CopySelectionRange(&st); + wxTheClipboard->UsePrimarySelection(true); + if (wxTheClipboard->Open()) { + wxString text = sci2wx(st.s, st.len); + wxTheClipboard->SetData(new wxTextDataObject(text)); + wxTheClipboard->Close(); + } + wxTheClipboard->UsePrimarySelection(false); + } +#endif +} + + +void ScintillaWX::UpdateSystemCaret() { +#ifdef __WXMSW__ + if (hasFocus) { + if (HasCaretSizeChanged()) { + DestroySystemCaret(); + CreateSystemCaret(); + } + Point pos = LocationFromPosition(sel.MainCaret()); +#if wxCHECK_VERSION(2, 5, 0) + ::SetCaretPos(pos.x, pos.y); +#endif + } +#endif +} + + +bool ScintillaWX::HasCaretSizeChanged() { +#ifdef __WXMSW__ +#if !wxCHECK_VERSION(2, 5, 0) + return false; +#else + if (( (0 != vs.caretWidth) && (sysCaretWidth != vs.caretWidth) ) + || (0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight)) { + return true; + } +#endif +#endif + return false; +} + +bool ScintillaWX::CreateSystemCaret() { +#ifdef __WXMSW__ +#if !wxCHECK_VERSION(2, 5, 0) + return false; +#else + sysCaretWidth = vs.caretWidth; + if (0 == sysCaretWidth) { + sysCaretWidth = 1; + } + sysCaretHeight = vs.lineHeight; + int bitmapSize = (((sysCaretWidth + 15) & ~15) >> 3) * sysCaretHeight; + char *bits = new char[bitmapSize]; + memset(bits, 0, bitmapSize); + sysCaretBitmap = ::CreateBitmap(sysCaretWidth, sysCaretHeight, 1, + 1, reinterpret_cast(bits)); + delete [] bits; + BOOL retval = ::CreateCaret(GetHwndOf(sci), sysCaretBitmap, + sysCaretWidth, sysCaretHeight); + ::ShowCaret(GetHwndOf(sci)); + return retval != 0; +#endif +#else + return false; +#endif +} + +bool ScintillaWX::DestroySystemCaret() { +#ifdef __WXMSW__ +#if !wxCHECK_VERSION(2, 5, 0) + return false; +#else + ::HideCaret(GetHwndOf(sci)); + BOOL retval = ::DestroyCaret(); + if (sysCaretBitmap) { + ::DeleteObject(sysCaretBitmap); + sysCaretBitmap = 0; + } + return retval != 0; +#endif +#else + return false; +#endif +} + + +//---------------------------------------------------------------------- + +long ScintillaWX::DefWndProc(unsigned int /*iMessage*/, unsigned long /*wParam*/, long /*lParam*/) { + return 0; +} + +long ScintillaWX::WndProc(unsigned int iMessage, unsigned long wParam, long lParam) { + switch (iMessage) { + case SCI_CALLTIPSHOWEXT: { + Point pt = LocationFromPosition(wParam); + char* defn = reinterpret_cast(lParam); + AutoCompleteCancel(); + + // If container knows about STYLE_CALLTIP then use it in place of the + // STYLE_DEFAULT for the face name, size and character set. Also use it + // for the foreground and background colour. + int ctStyle = ct.UseStyleCallTip() ? STYLE_CALLTIP : STYLE_DEFAULT; + + PRectangle rc = ct.CallTipStart(sel.MainCaret(), pt, + defn, + vs.styles[ctStyle].fontName, + vs.styles[ctStyle].sizeZoomed, + CodePage(), + vs.styles[ctStyle].characterSet, + wMain); + int tipHeight = rc.Height(); + int tipWidth = rc.Width(); + + // handle the Y axis + int h = rc.Height(); + rc.top = sci->m_ccPoint.y; + rc.bottom = rc.top + h; + + // Adjust the X coordinates of the tip + rc.left = sci->m_ccPoint.x + 250; + rc.right = rc.left + tipWidth; + rc.top = sci->m_ccPoint.y; + rc.bottom = rc.top + tipHeight; + + // If the call-tip window would be out of the client + // space, adjust so it displays above the text. + + // Convert the cilent position to screen position + // and perform all calculations based on screen size + // once done, convert the result back to client coords + static int ww(-1); + static int hh(-1); + if(hh == -1 || ww == -1) + ::wxDisplaySize(&ww, &hh); + + wxRect rr = wxRectFromPRectangle(rc); + wxPoint parentPt = sci->ClientToScreen(rr.GetLeftTop()); + wxPoint parentCCBoxPt = sci->ClientToScreen(sci->m_ccPoint); + + rr.SetTopLeft( parentPt ); + + ///////////////////////////////////////////////////////// + // Adjust the Y axis + ///////////////////////////////////////////////////////// + + if (rr.GetBottom() > hh) { + int offset = (rr.GetBottom()- hh); + rr.y -= offset; + + if(rr.y < 0) { + rr.y = 0; + } + } + + if(rr.GetRight() > ww) { + int fallbackX = rr.x; + rr.x = parentCCBoxPt.x; + rr.x -= tipWidth; + + if(rr.x < 0) { + // moving the tip to the left is not good also + // fallback + rr.x = fallbackX; + } + } + + // Convert the 'rr' into Client Coords + wxPoint clientPt = sci->ScreenToClient(rr.GetTopLeft()); + rr.SetTopLeft( clientPt ); + rc = PRectangle(rr.GetLeft(), rr.GetTop(), rr.GetRight()+1, rr.GetBottom()+1); + + if(sci->m_isTipBgDark) { + ct.colourDoxyHighlight = ColourAllocated( ColourDesired(0, 255, 0).AsLong() ); + ct.colourDivider = ColourAllocated( ColourDesired(255, 255, 255).AsLong() ); + } + + // Now display the window. + CreateCallTipWindow(rc); + ct.wCallTip.SetPositionRelative(rc, wMain); + ct.wCallTip.Show(); + break; + } + case SCI_CALLTIPSHOW: { + // NOTE: This is copied here from scintilla/src/ScintillaBase.cxx + // because of the little tweak that needs done below for wxGTK. + // When updating new versions double check that this is still + // needed, and that any new code there is copied here too. + Point pt = LocationFromPosition(wParam); + char* defn = reinterpret_cast(lParam); + AutoCompleteCancel(); + pt.y += vs.lineHeight; + + int ctStyle = ct.UseStyleCallTip() ? STYLE_CALLTIP : STYLE_DEFAULT; + PRectangle rc = ct.CallTipStart(sel.MainCaret(), pt, + defn, + vs.styles[ctStyle].fontName, + vs.styles[ctStyle].sizeZoomed, + CodePage(), + vs.styles[ctStyle].characterSet, + wMain); + // If the call-tip window would be out of the client + // space, adjust so it displays above the text. + PRectangle rcClient = GetClientRectangle(); + if (rc.bottom > rcClient.bottom) { +#ifdef __WXGTK__ + int offset = int(vs.lineHeight * 1.25) + rc.Height(); +#else + int offset = vs.lineHeight + rc.Height(); +#endif + rc.top -= offset; + rc.bottom -= offset; + } + // Now display the window. + CreateCallTipWindow(rc); + ct.wCallTip.SetPositionRelative(rc, wMain); + ct.wCallTip.Show(); + break; + } + /*? TODO + #ifdef SCI_LEXER + case SCI_LOADLEXERLIBRARY: + LexerManager::GetInstance()->Load((const char*)lParam); + break; + #endif ?*/ + default: + return ScintillaBase::WndProc(iMessage, wParam, lParam); + } + return 0; +} + + + +//---------------------------------------------------------------------- +// Event delegates + +void ScintillaWX::DoPaint(wxDC* dc, wxRect rect) { + + paintState = painting; + Surface* surfaceWindow = Surface::Allocate(); + surfaceWindow->Init(dc, wMain.GetID()); + rcPaint = PRectangleFromwxRect(rect); + PRectangle rcClient = GetClientRectangle(); + paintingAllText = rcPaint.Contains(rcClient); + + ClipChildren(*dc, rcPaint); + Paint(surfaceWindow, rcPaint); + + delete surfaceWindow; + if (paintState == paintAbandoned) { + // Painting area was insufficient to cover new styling or brace + // highlight positions + FullPaint(); + } + paintState = notPainting; +} + + +void ScintillaWX::DoHScroll(int type, int pos) { + int xPos = xOffset; + PRectangle rcText = GetTextRectangle(); + int pageWidth = rcText.Width() * 2 / 3; + if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP) + xPos -= H_SCROLL_STEP; + else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN) + xPos += H_SCROLL_STEP; + else if (type == wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP) + xPos -= pageWidth; + else if (type == wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN) { + xPos += pageWidth; + if (xPos > scrollWidth - rcText.Width()) { + xPos = scrollWidth - rcText.Width(); + } + } else if (type == wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP) + xPos = 0; + else if (type == wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM) + xPos = scrollWidth; + else if (type == wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK) + xPos = pos; + + HorizontalScrollTo(xPos); +} + +void ScintillaWX::DoVScroll(int type, int pos) { + int topLineNew = topLine; + if (type == wxEVT_SCROLLWIN_LINEUP || type == wxEVT_SCROLL_LINEUP) + topLineNew -= 1; + else if (type == wxEVT_SCROLLWIN_LINEDOWN || type == wxEVT_SCROLL_LINEDOWN) + topLineNew += 1; + else if (type == wxEVT_SCROLLWIN_PAGEUP || type == wxEVT_SCROLL_PAGEUP) + topLineNew -= LinesToScroll(); + else if (type == wxEVT_SCROLLWIN_PAGEDOWN || type == wxEVT_SCROLL_PAGEDOWN) + topLineNew += LinesToScroll(); + else if (type == wxEVT_SCROLLWIN_TOP || type == wxEVT_SCROLL_TOP) + topLineNew = 0; + else if (type == wxEVT_SCROLLWIN_BOTTOM || type == wxEVT_SCROLL_BOTTOM) + topLineNew = MaxScrollPos(); + else if (type == wxEVT_SCROLLWIN_THUMBTRACK || type == wxEVT_SCROLL_THUMBTRACK) + topLineNew = pos; + + ScrollTo(topLineNew); +} + +void ScintillaWX::DoMouseWheel(int rotation, int delta, + int linesPerAction, int ctrlDown, + bool isPageScroll ) { + int topLineNew = topLine; + int lines; + + if (ctrlDown) { // Zoom the fonts if Ctrl key down + if (rotation < 0) { + KeyCommand(SCI_ZOOMIN); + } else { + KeyCommand(SCI_ZOOMOUT); + } + } else { // otherwise just scroll the window + if ( !delta ) + delta = 120; + wheelRotation += rotation; + lines = wheelRotation / delta; + wheelRotation -= lines * delta; + if (lines != 0) { + if (isPageScroll) + lines = lines * LinesOnScreen(); // lines is either +1 or -1 + else + lines *= linesPerAction; + topLineNew -= lines; + ScrollTo(topLineNew); + } + } +} + + +void ScintillaWX::DoSize(int WXUNUSED(width), int WXUNUSED(height)) { + ChangeSize(); +} + +void ScintillaWX::DoLoseFocus() { + focusEvent = true; + SetFocusState(false); + focusEvent = false; + DestroySystemCaret(); +} + +void ScintillaWX::DoGainFocus() { + focusEvent = true; + SetFocusState(true); + focusEvent = false; + DestroySystemCaret(); + CreateSystemCaret(); +} + +void ScintillaWX::DoSysColourChange() { + InvalidateStyleData(); +} + +void ScintillaWX::DoLeftButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) { + ButtonDown(pt, curTime, shift, ctrl, alt); +} + +void ScintillaWX::DoLeftButtonUp(Point pt, unsigned int curTime, bool ctrl) { + ButtonUp(pt, curTime, ctrl); +#if wxUSE_DRAG_AND_DROP + if (startDragTimer->IsRunning()) { + startDragTimer->Stop(); + SetDragPosition(SelectionPosition(invalidPosition)); + SetEmptySelection(PositionFromLocation(pt)); + ShowCaretAtCurrentPosition(); + } +#endif +} + +void ScintillaWX::DoLeftButtonMove(Point pt) { + ButtonMove(pt); +} + +#ifdef __WXGTK__ +void ScintillaWX::DoMiddleButtonUp(Point pt) { + // Set the current position to the mouse click point and + // then paste in the PRIMARY selection, if any. wxGTK only. + int newPos = PositionFromLocation(pt); + MovePositionTo(newPos, Selection::noSel, true); + + pdoc->BeginUndoAction(); + wxTextDataObject data; + bool gotData = false; + wxTheClipboard->UsePrimarySelection(true); + if (wxTheClipboard->Open()) { + gotData = wxTheClipboard->GetData(data); + wxTheClipboard->Close(); + } + wxTheClipboard->UsePrimarySelection(false); + if (gotData) { + wxString text = wxTextBuffer::Translate (data.GetText(), + wxConvertEOLMode(pdoc->eolMode)); + data.SetText(wxEmptyString); // free the data object content + wxWX2MBbuf buf = (wxWX2MBbuf)wx2sci(text); + int len = strlen(buf); + pdoc->InsertString(sel.MainCaret(), buf, len); + SetEmptySelection(sel.MainCaret() + len); + } + pdoc->EndUndoAction(); + NotifyChange(); + Redraw(); + + ShowCaretAtCurrentPosition(); + EnsureCaretVisible(); +} +#else +void ScintillaWX::DoMiddleButtonUp(Point WXUNUSED(pt)) { +} +#endif + + +void ScintillaWX::DoAddChar(int key) { +#if wxUSE_UNICODE + wxChar wszChars[2]; + wszChars[0] = (wxChar)key; + wszChars[1] = 0; + wxWX2MBbuf buf = (wxWX2MBbuf)wx2sci(wszChars); + AddCharUTF((char*)buf.data(), strlen(buf)); +#else + AddChar((char)key); +#endif +} + + +int ScintillaWX::DoKeyDown(const wxKeyEvent& evt, bool* consumed) { + int key = evt.GetKeyCode(); + bool shift = evt.ShiftDown(), + ctrl = evt.ControlDown(), + alt = evt.AltDown(); + + if (ctrl && key >= 1 && key <= 26 && key != WXK_BACK) + key += 'A' - 1; + + switch (key) { + case WXK_DOWN: // fall through + case WXK_NUMPAD_DOWN: + key = SCK_DOWN; + break; + case WXK_UP: // fall through + case WXK_NUMPAD_UP: + key = SCK_UP; + break; + case WXK_LEFT: // fall through + case WXK_NUMPAD_LEFT: + key = SCK_LEFT; + break; + case WXK_RIGHT: // fall through + case WXK_NUMPAD_RIGHT: + key = SCK_RIGHT; + break; + case WXK_HOME: // fall through + case WXK_NUMPAD_HOME: + key = SCK_HOME; + break; + case WXK_END: // fall through + case WXK_NUMPAD_END: + key = SCK_END; + break; +#if !wxCHECK_VERSION(2, 7, 0) + case WXK_PRIOR: // fall through + case WXK_NUMPAD_PRIOR: // fall through +#endif + case WXK_PAGEUP: // fall through + case WXK_NUMPAD_PAGEUP: + key = SCK_PRIOR; + break; +#if !wxCHECK_VERSION(2, 7, 0) + case WXK_NEXT: // fall through + case WXK_NUMPAD_NEXT: // fall through +#endif + case WXK_PAGEDOWN: // fall through + case WXK_NUMPAD_PAGEDOWN: + key = SCK_NEXT; + break; + //Eran - BEGIN + case WXK_NUMPAD_DELETE: //fall through + //Eran - END + case WXK_DELETE: + key = SCK_DELETE; + break; + + //Eran - BEGIN + case WXK_NUMPAD_INSERT://fall through + //Eran - END + case WXK_INSERT: + key = SCK_INSERT; + break; + case WXK_ESCAPE: + key = SCK_ESCAPE; + break; + case WXK_BACK: + key = SCK_BACK; + break; + case WXK_TAB: + key = SCK_TAB; + break; + case WXK_RETURN: // fall through + case WXK_NUMPAD_ENTER: + key = SCK_RETURN; + break; + case WXK_ADD: // fall through + case WXK_NUMPAD_ADD: + key = SCK_ADD; + break; + case WXK_SUBTRACT: // fall through + case WXK_NUMPAD_SUBTRACT: + key = SCK_SUBTRACT; + break; + case WXK_DIVIDE: // fall through + case WXK_NUMPAD_DIVIDE: + key = SCK_DIVIDE; + break; + case WXK_CONTROL: + key = 0; + break; + case WXK_ALT: + key = 0; + break; + case WXK_SHIFT: + key = 0; + break; + case WXK_MENU: + key = 0; + break; + } + +#ifdef __WXMAC__ + if ( evt.MetaDown() ) { + // check for a few common Mac Meta-key combos and remap them to Ctrl + // for Scintilla + switch ( key ) { + case 'Z': // Undo + case 'X': // Cut + case 'C': // Copy + case 'V': // Paste + case 'A': // Select All + ctrl = true; + break; + } + } +#endif + + int rv = KeyDown(key, shift, ctrl, alt, consumed); + + if (key) + return rv; + else + return 1; +} + + +void ScintillaWX::DoCommand(int ID) { + Command(ID); +} + + +void ScintillaWX::DoContextMenu(Point pt) { + if (displayPopupMenu) + ContextMenu(pt); +} + +void ScintillaWX::DoOnListBox() { + AutoCompleteCompleted(); +} + + +void ScintillaWX::DoOnIdle(wxIdleEvent& evt) { + + if ( Idle() ) + evt.RequestMore(); + else + SetIdle(false); +} + +//---------------------------------------------------------------------- + +#if wxUSE_DRAG_AND_DROP +bool ScintillaWX::DoDropText(long x, long y, const wxString& data) { + SetDragPosition(SelectionPosition(invalidPosition)); + + wxString text = wxTextBuffer::Translate (data, wxConvertEOLMode(pdoc->eolMode)); + + // Send an event to allow the drag details to be changed + wxScintillaEvent evt(wxEVT_SCI_DO_DROP, sci->GetId()); + evt.SetEventObject(sci); + evt.SetDragResult(dragResult); + evt.SetX(x); + evt.SetY(y); + evt.SetPosition(PositionFromLocation(Point(x,y))); + evt.SetDragText(text); + sci->GetEventHandler()->ProcessEvent(evt); + + dragResult = evt.GetDragResult(); + if (dragResult == wxDragMove || dragResult == wxDragCopy) { + DropAt( SelectionPosition(evt.GetPosition()), + wx2sci(evt.GetDragText()), + dragResult == wxDragMove, + dragRectangle); + return true; + } + return false; +} + + +wxDragResult ScintillaWX::DoDragEnter(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxDragResult def) { + dragResult = def; + return dragResult; +} + + +wxDragResult ScintillaWX::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) { + SetDragPosition(SelectionPosition( PositionFromLocation(Point(x, y)) ) ); + + // Send an event to allow the drag result to be changed + wxScintillaEvent evt(wxEVT_SCI_DRAG_OVER, sci->GetId()); + evt.SetEventObject(sci); + evt.SetDragResult(def); + evt.SetX(x); + evt.SetY(y); + evt.SetPosition(PositionFromLocation(Point(x,y))); + sci->GetEventHandler()->ProcessEvent(evt); + + dragResult = evt.GetDragResult(); + return dragResult; +} + + +void ScintillaWX::DoDragLeave() { + SetDragPosition(SelectionPosition(invalidPosition)); +} +#endif +//---------------------------------------------------------------------- + +// Force the whole window to be repainted +void ScintillaWX::FullPaint() { +#ifndef __WXMAC__ + sci->Refresh(false); +#endif + sci->Update(); +} + + +void ScintillaWX::DoScrollToLine(int line) { + ScrollTo(line); +} + + +void ScintillaWX::DoScrollToColumn(int column) { + HorizontalScrollTo(column * vs.spaceWidth); +} + +#ifdef __WXGTK__ +void ScintillaWX::ClipChildren(wxDC& dc, PRectangle rect) { +// wxGTK > 2.5 doesn't appear to need this explicit clipping code any longer +#if !wxCHECK_VERSION(2, 5, 0) + wxRegion rgn(wxRectFromPRectangle(rect)); + if (ac.Active()) { + wxRect childRect = ((wxWindow*)ac.lb->GetID())->GetRect(); + rgn.Subtract(childRect); + } + if (ct.inCallTipMode) { + wxSCICallTip* tip = (wxSCICallTip*)ct.wCallTip.GetID(); + wxRect childRect = tip->GetRect(); +#if wxUSE_POPUPWIN && wxSCI_USE_POPUP + childRect.SetPosition(tip->GetMyPosition()); +#endif + rgn.Subtract(childRect); + } + + dc.SetClippingRegion(rgn); +#endif +} +#else +void ScintillaWX::ClipChildren(wxDC& WXUNUSED(dc), PRectangle WXUNUSED(rect)) { +} +#endif + + +void ScintillaWX::SetUseAntiAliasing(bool useAA) { + vs.extraFontFlag = useAA; + InvalidateStyleRedraw(); +} + +bool ScintillaWX::GetUseAntiAliasing() { + return vs.extraFontFlag; +} + +//---------------------------------------------------------------------- +//---------------------------------------------------------------------- diff --git a/sdk/wxscintilla/src/ScintillaWX.h b/sdk/wxscintilla/src/ScintillaWX.h new file mode 100644 index 0000000..2aef4a5 --- /dev/null +++ b/sdk/wxscintilla/src/ScintillaWX.h @@ -0,0 +1,214 @@ +//////////////////////////////////////////////////////////////////////////// +// Name: ScintillaWX.h +// Purpose: A wxWidgets implementation of Scintilla. A class derived +// from ScintillaBase that uses the "wx platform" defined in +// PlatWX.cpp. This class is one end of a bridge between +// the wx world and the Scintilla world. It needs a peer +// object of type wxScintilla to function. +// +// Author: Robin Dunn +// +// Created: 13-Jan-2000 +// RCS-ID: $Id: ScintillaWX.h,v 1.9 2006/06/06 19:16:25 wyo Exp $ +// Copyright: (c) 2000 by Total Control Software +// Licence: wxWindows license +///////////////////////////////////////////////////////////////////////////// + +#ifndef __ScintillaWX_h__ +#define __ScintillaWX_h__ +// [CHANGED] BEGIN +#include +#include +#include +#include +#include +#include "Platform.h" +#include "SplitVector.h" +#include "Partitioning.h" +#include "RunStyles.h" +#include "Scintilla.h" +#include "ScintillaWidget.h" +#ifdef SCI_LEXER +#include "SciLexer.h" +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#endif +#include "ContractionState.h" +#include "SVector.h" +#include "CellBuffer.h" +#include "CallTip.h" +#include "KeyMap.h" +#include "Indicator.h" +#include "XPM.h" +#include "LineMarker.h" +#include "Style.h" +#include "AutoComplete.h" +#include "ViewStyle.h" +#include "CharClassify.h" +#include "Decoration.h" +#include "Document.h" +#include "Selection.h" +#include "PositionCache.h" +#include "Editor.h" +#include "SString.h" +#include "PropSetSimple.h" +#include "ScintillaBase.h" +#include +#include +#include +#include +// [CHANGED] END + +#ifdef WXMAKINGDLL_SCI + #define WXDLLIMPEXP_SCI WXEXPORT +#elif defined(WXUSINGDLL_SCI) + #define WXDLLIMPEXP_SCI WXIMPORT +#else // not making nor using DLL + #define WXDLLIMPEXP_SCI +#endif + +class WXDLLIMPEXP_SCI wxScintilla; // forward +class ScintillaWX; + +#ifndef SCI_SCOPE // begin [CHANGED] + #ifdef SCI_NAMESPACE + #define SCI_SCOPE( x ) Scintilla::x + #else + #define SCI_SCOPE( x ) x + #endif +#endif // end [CHANGED] +//---------------------------------------------------------------------- +// Helper classes + +#if wxUSE_DRAG_AND_DROP +class wxSCIDropTarget : public wxTextDropTarget { +public: + void SetScintilla(ScintillaWX* swx) { + this->swx = swx; + } + + bool OnDropText(wxCoord x, wxCoord y, const wxString& data); + wxDragResult OnEnter(wxCoord x, wxCoord y, wxDragResult def); + wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def); + void OnLeave(); + +private: + ScintillaWX* swx; +}; +#endif + +//---------------------------------------------------------------------- + +class ScintillaWX : public SCI_SCOPE( ScintillaBase ) { +public: + + ScintillaWX(wxScintilla* win); + ~ScintillaWX(); + + // base class virtuals + virtual void Initialise(); + virtual void Finalise(); + virtual void StartDrag(); + virtual bool SetIdle(bool on); + virtual void SetTicking(bool on); + virtual void SetMouseCapture(bool on); + virtual bool HaveMouseCapture(); + virtual void ScrollText(int linesToMove); + virtual void SetVerticalScrollPos(); + virtual void SetHorizontalScrollPos(); + virtual bool ModifyScrollBars(int nMax, int nPage); + virtual void Copy(); + virtual void Paste(); + virtual void CopyToClipboard(const SCI_SCOPE(SelectionText) &selectedText); + + virtual void CreateCallTipWindow( SCI_SCOPE(PRectangle) rc); + virtual void AddToPopUp(const char *label, int cmd = 0, bool enabled = true); + virtual void ClaimSelection(); + + virtual long DefWndProc(unsigned int iMessage, + unsigned long wParam, + long lParam); + virtual long WndProc(unsigned int iMessage, + unsigned long wParam, + long lParam); + + virtual void NotifyChange(); + virtual void NotifyParent( SCI_SCOPE(SCNotification) scn); + + virtual void CancelModes(); + + virtual void UpdateSystemCaret(); + + // Event delegates + void DoPaint(wxDC* dc, wxRect rect); + void DoHScroll(int type, int pos); + void DoVScroll(int type, int pos); + void DoSize(int width, int height); + void DoLoseFocus(); + void DoGainFocus(); + void DoSysColourChange(); + void DoLeftButtonDown( SCI_SCOPE(Point) pt, unsigned int curTime, bool shift, bool ctrl, bool alt); // [CHANGED] + void DoLeftButtonUp(SCI_SCOPE(Point) pt, unsigned int curTime, bool ctrl); // [CHANGED] + void DoLeftButtonMove(SCI_SCOPE(Point) pt); // [CHANGED] + void DoMiddleButtonUp(SCI_SCOPE(Point) pt); // [CHANGED] + void DoMouseWheel(int rotation, int delta, int linesPerAction, int ctrlDown, bool isPageScroll); + void DoAddChar(int key); + int DoKeyDown(const wxKeyEvent& event, bool* consumed); + void DoTick() { Tick(); } + void DoOnIdle(wxIdleEvent& evt); + void DoStartDrag(); + +#if wxUSE_DRAG_AND_DROP + bool DoDropText(long x, long y, const wxString& data); + wxDragResult DoDragEnter(wxCoord x, wxCoord y, wxDragResult def); + wxDragResult DoDragOver(wxCoord x, wxCoord y, wxDragResult def); + void DoDragLeave(); +#endif + + void DoCommand(int ID); + void DoContextMenu(SCI_SCOPE(Point) pt); // [CHANGED] + void DoOnListBox(); + + + // helpers + void FullPaint(); + bool CanPaste(); + bool GetHideSelection() { return hideSelection; } + void DoScrollToLine(int line); + void DoScrollToColumn(int column); + void ClipChildren(wxDC& dc, SCI_SCOPE(PRectangle) rect); + void SetUseAntiAliasing(bool useAA); + bool GetUseAntiAliasing(); + +private: + bool capturedMouse; + bool focusEvent; + wxScintilla* sci; + +#if wxUSE_DRAG_AND_DROP + wxSCIDropTarget* dropTarget; + wxDragResult dragResult; + bool dragRectangle; + wxTimer* startDragTimer; +#endif + + int wheelRotation; + + // For use in creating a system caret + bool HasCaretSizeChanged(); + bool CreateSystemCaret(); + bool DestroySystemCaret(); +#ifdef __WXMSW__ +#if wxCHECK_VERSION(2, 5, 0) + HBITMAP sysCaretBitmap; + int sysCaretWidth; + int sysCaretHeight; +#endif +#endif + + friend class wxSCICallTip; +}; + +//---------------------------------------------------------------------- +#endif diff --git a/sdk/wxscintilla/src/gtkstring.h b/sdk/wxscintilla/src/gtkstring.h new file mode 100644 index 0000000..38e4482 --- /dev/null +++ b/sdk/wxscintilla/src/gtkstring.h @@ -0,0 +1,39 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: wx/gtk/private/string.h +// Purpose: MyGtkString class declaration +// Author: Vadim Zeitlin +// Created: 2006-10-19 +// RCS-ID: $Id$ +// Copyright: (c) 2006 Vadim Zeitlin +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// +#ifdef __WXGTK__ +#ifndef _GTK_PRIVATE_STRING_H_ +#define _GTK_PRIVATE_STRING_H_ + +// ---------------------------------------------------------------------------- +// Convenience class for g_freeing a gchar* on scope exit automatically +// ---------------------------------------------------------------------------- +#ifdef __WXGTK20__ +#include +#endif +class MyGtkString +{ +public: + explicit MyGtkString(gchar *s) : m_str(s) { } + ~MyGtkString() { g_free(m_str); } + + const gchar *c_str() const { return m_str; } + + operator gchar *() const { return m_str; } + +private: + gchar *m_str; + + DECLARE_NO_COPY_CLASS(MyGtkString) +}; + +#endif // _WX_GTK_PRIVATE_STRING_H_ + + +#endif //__WXGTK__ diff --git a/sdk/wxscintilla/src/scintilla/License.txt b/sdk/wxscintilla/src/scintilla/License.txt new file mode 100644 index 0000000..cbe25b2 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/License.txt @@ -0,0 +1,20 @@ +License for Scintilla and SciTE + +Copyright 1998-2003 by Neil Hodgson + +All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation. + +NEIL HODGSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS, IN NO EVENT SHALL NEIL HODGSON BE LIABLE FOR ANY +SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE +OR PERFORMANCE OF THIS SOFTWARE. \ No newline at end of file diff --git a/sdk/wxscintilla/src/scintilla/README.txt b/sdk/wxscintilla/src/scintilla/README.txt new file mode 100644 index 0000000..498a29c --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/README.txt @@ -0,0 +1,5 @@ +This directory contains copies of the scintilla/src and +scintilla/include directories from the Scintilla source +distribution. + +The current version of the Scintilla code is 1.62 diff --git a/sdk/wxscintilla/src/scintilla/include/Accessor.h b/sdk/wxscintilla/src/scintilla/include/Accessor.h new file mode 100644 index 0000000..bfe4d4d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/Accessor.h @@ -0,0 +1,79 @@ +// Scintilla source code edit control +/** @file Accessor.h + ** Rapid easy access to contents of a Scintilla. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +enum { wsSpace = 1, wsTab = 2, wsSpaceTab = 4, wsInconsistent=8}; + +class Accessor; + +typedef bool (*PFNIsCommentLeader)(Accessor &styler, int pos, int len); + +/** + * Interface to data in a Scintilla. + */ +class Accessor { +protected: + enum {extremePosition=0x7FFFFFFF}; + /** @a bufferSize is a trade off between time taken to copy the characters + * and retrieval overhead. + * @a slopSize positions the buffer before the desired position + * in case there is some backtracking. */ + enum {bufferSize=4000, slopSize=bufferSize/8}; + char buf[bufferSize+1]; + int startPos; + int endPos; + int codePage; + + virtual bool InternalIsLeadByte(char ch)=0; + virtual void Fill(int position)=0; + +public: + Accessor() : startPos(extremePosition), endPos(0), codePage(0) {} + virtual ~Accessor() {} + char operator[](int position) { + if (position < startPos || position >= endPos) { + Fill(position); + } + return buf[position - startPos]; + } + /** Safe version of operator[], returning a defined value for invalid position. */ + char SafeGetCharAt(int position, char chDefault=' ') { + if (position < startPos || position >= endPos) { + Fill(position); + if (position < startPos || position >= endPos) { + // Position is outside range of document + return chDefault; + } + } + return buf[position - startPos]; + } + bool IsLeadByte(char ch) { + return codePage && InternalIsLeadByte(ch); + } + void SetCodePage(int codePage_) { codePage = codePage_; } + + virtual bool Match(int pos, const char *s)=0; + virtual char StyleAt(int position)=0; + virtual int GetLine(int position)=0; + virtual int LineStart(int line)=0; + virtual int LevelAt(int line)=0; + virtual int Length()=0; + virtual void Flush()=0; + virtual int GetLineState(int line)=0; + virtual int SetLineState(int line, int state)=0; + virtual int GetPropertyInt(const char *key, int defaultValue=0)=0; + virtual char *GetProperties()=0; + + // Style setting + virtual void StartAt(unsigned int start, char chMask=31)=0; + virtual void SetFlags(char chFlags_, char chWhile_)=0; + virtual unsigned int GetStartSegment()=0; + virtual void StartSegment(unsigned int pos)=0; + virtual void ColourTo(unsigned int pos, int chAttr)=0; + virtual void SetLevel(int line, int level)=0; + virtual int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0)=0; + virtual void IndicatorFill(int start, int end, int indicator, int value)=0; +}; diff --git a/sdk/wxscintilla/src/scintilla/include/Face.py b/sdk/wxscintilla/src/scintilla/include/Face.py new file mode 100644 index 0000000..52c9b8d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/Face.py @@ -0,0 +1,110 @@ +# Module for reading and parsing Scintilla.iface file + +def sanitiseLine(line): + if line[-1:] == '\n': line = line[:-1] + if line.find("##") != -1: + line = line[:line.find("##")] + line = line.strip() + return line + +def decodeFunction(featureVal): + retType, rest = featureVal.split(" ", 1) + nameIdent, params = rest.split("(") + name, value = nameIdent.split("=") + params, rest = params.split(")") + param1, param2 = params.split(",")[0:2] + return retType, name, value, param1, param2 + +def decodeEvent(featureVal): + retType, rest = featureVal.split(" ", 1) + nameIdent, params = rest.split("(") + name, value = nameIdent.split("=") + return retType, name, value + +def decodeParam(p): + param = p.strip() + type = "" + name = "" + value = "" + if " " in param: + type, nv = param.split(" ") + if "=" in nv: + name, value = nv.split("=") + else: + name = nv + return type, name, value + +class Face: + + def __init__(self): + self.order = [] + self.features = {} + self.values = {} + self.events = {} + + def ReadFromFile(self, name): + currentCategory = "" + currentComment = [] + currentCommentFinished = 0 + file = open(name) + for line in file.readlines(): + line = sanitiseLine(line) + if line: + if line[0] == "#": + if line[1] == " ": + if currentCommentFinished: + currentComment = [] + currentCommentFinished = 0 + currentComment.append(line[2:]) + else: + currentCommentFinished = 1 + featureType, featureVal = line.split(" ", 1) + if featureType in ["fun", "get", "set"]: + retType, name, value, param1, param2 = decodeFunction(featureVal) + p1 = decodeParam(param1) + p2 = decodeParam(param2) + self.features[name] = { + "FeatureType": featureType, + "ReturnType": retType, + "Value": value, + "Param1Type": p1[0], "Param1Name": p1[1], "Param1Value": p1[2], + "Param2Type": p2[0], "Param2Name": p2[1], "Param2Value": p2[2], + "Category": currentCategory, "Comment": currentComment + } + if value in self.values: + raise "Duplicate value " + value + " " + name + self.values[value] = 1 + self.order.append(name) + elif featureType == "evt": + retType, name, value = decodeEvent(featureVal) + self.features[name] = { + "FeatureType": featureType, + "ReturnType": retType, + "Value": value, + "Category": currentCategory, "Comment": currentComment + } + if value in self.events: + raise "Duplicate event " + value + " " + name + self.events[value] = 1 + self.order.append(name) + elif featureType == "cat": + currentCategory = featureVal + elif featureType == "val": + try: + name, value = featureVal.split("=", 1) + except ValueError: + print("Failure %s" % featureVal) + raise + self.features[name] = { + "FeatureType": featureType, + "Category": currentCategory, + "Value": value } + self.order.append(name) + elif featureType == "enu" or featureType == "lex": + name, value = featureVal.split("=", 1) + self.features[name] = { + "FeatureType": featureType, + "Category": currentCategory, + "Value": value } + self.order.append(name) + diff --git a/sdk/wxscintilla/src/scintilla/include/HFacer.py b/sdk/wxscintilla/src/scintilla/include/HFacer.py new file mode 100644 index 0000000..62a8273 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/HFacer.py @@ -0,0 +1,75 @@ +# HFacer.py - regenerate the Scintilla.h and SciLexer.h files from the Scintilla.iface interface +# definition file. +# The header files are copied to a temporary file apart from the section between a /* ++Autogenerated*/ +# comment and a /* --Autogenerated*/ comment which is generated by the printHFile and printLexHFile +# functions. After the temporary file is created, it is copied back to the original file name. + +import sys +import os +import Face + +def Contains(s,sub): + return s.find(sub) != -1 + +def printLexHFile(f,out): + for name in f.order: + v = f.features[name] + if v["FeatureType"] in ["val"]: + if Contains(name, "SCE_") or Contains(name, "SCLEX_"): + out.write("#define " + name + " " + v["Value"] + "\n") + +def printHFile(f,out): + for name in f.order: + v = f.features[name] + if v["Category"] != "Deprecated": + if v["FeatureType"] in ["fun", "get", "set"]: + featureDefineName = "SCI_" + name.upper() + out.write("#define " + featureDefineName + " " + v["Value"] + "\n") + elif v["FeatureType"] in ["evt"]: + featureDefineName = "SCN_" + name.upper() + out.write("#define " + featureDefineName + " " + v["Value"] + "\n") + elif v["FeatureType"] in ["val"]: + if not (Contains(name, "SCE_") or Contains(name, "SCLEX_")): + out.write("#define " + name + " " + v["Value"] + "\n") + +def CopyWithInsertion(input, output, genfn, definition): + copying = 1 + for line in input.readlines(): + if copying: + output.write(line) + if Contains(line, "/* ++Autogenerated"): + copying = 0 + genfn(definition, output) + if Contains(line, "/* --Autogenerated"): + copying = 1 + output.write(line) + +def contents(filename): + f = open(filename) + t = f.read() + f.close() + return t + +def Regenerate(filename, genfn, definition): + inText = contents(filename) + tempname = "HFacer.tmp" + out = open(tempname,"w") + hfile = open(filename) + CopyWithInsertion(hfile, out, genfn, definition) + out.close() + hfile.close() + outText = contents(tempname) + if inText == outText: + os.unlink(tempname) + else: + os.unlink(filename) + os.rename(tempname, filename) + +f = Face.Face() +try: + f.ReadFromFile("Scintilla.iface") + Regenerate("Scintilla.h", printHFile, f) + Regenerate("SciLexer.h", printLexHFile, f) + print("Maximum ID is %s" % max([x for x in f.values if int(x) < 3000])) +except: + raise diff --git a/sdk/wxscintilla/src/scintilla/include/KeyWords.h b/sdk/wxscintilla/src/scintilla/include/KeyWords.h new file mode 100644 index 0000000..5593b7d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/KeyWords.h @@ -0,0 +1,113 @@ +// Scintilla source code edit control +/** @file KeyWords.h + ** Colourise for particular languages. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ +class WordList { +public: + // Each word contains at least one character - a empty word acts as sentinel at the end. + char **words; + char *list; + int len; + bool onlyLineEnds; ///< Delimited by any white space or only line ends + bool sorted; + int starts[256]; + WordList(bool onlyLineEnds_ = false) : + words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_), + sorted(false) + {} + ~WordList() { Clear(); } + operator bool() { return len ? true : false; } + void Clear(); + void Set(const char *s); + bool InList(const char *s); + bool InListAbbreviated(const char *s, const char marker); +}; + +typedef void (*LexerFunction)(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler); + +/** + * A LexerModule is responsible for lexing and folding a particular language. + * The class maintains a list of LexerModules which can be searched to find a + * module appropriate to a particular language. + */ +class LexerModule { +protected: + const LexerModule *next; + int language; + LexerFunction fnLexer; + LexerFunction fnFolder; + const char * const * wordListDescriptions; + int styleBits; + + static const LexerModule *base; + static int nextLanguage; + +public: + const char *languageName; + LexerModule(int language_, + LexerFunction fnLexer_, + const char *languageName_=0, + LexerFunction fnFolder_=0, + const char * const wordListDescriptions_[] = NULL, + int styleBits_=5); + virtual ~LexerModule() { + } + int GetLanguage() const { return language; } + + // -1 is returned if no WordList information is available + int GetNumWordLists() const; + const char *GetWordListDescription(int index) const; + + int GetStyleBitsNeeded() const; + + virtual void Lex(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const; + virtual void Fold(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const; + static const LexerModule *Find(int language); + static const LexerModule *Find(const char *languageName); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +/** + * Check if a character is a space. + * This is ASCII specific but is safe with chars >= 0x80. + */ +inline bool isspacechar(unsigned char ch) { + return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d)); +} + +inline bool iswordchar(char ch) { + return isascii(ch) && (isalnum(ch) || ch == '.' || ch == '_'); +} + +inline bool iswordstart(char ch) { + return isascii(ch) && (isalnum(ch) || ch == '_'); +} + +inline bool isoperator(char ch) { + if (isascii(ch) && isalnum(ch)) + return false; + // '.' left out as it is used to make up numbers + if (ch == '%' || ch == '^' || ch == '&' || ch == '*' || + ch == '(' || ch == ')' || ch == '-' || ch == '+' || + ch == '=' || ch == '|' || ch == '{' || ch == '}' || + ch == '[' || ch == ']' || ch == ':' || ch == ';' || + ch == '<' || ch == '>' || ch == ',' || ch == '/' || + ch == '?' || ch == '!' || ch == '.' || ch == '~') + return true; + return false; +} diff --git a/sdk/wxscintilla/src/scintilla/include/Platform.h b/sdk/wxscintilla/src/scintilla/include/Platform.h new file mode 100644 index 0000000..b37f956 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/Platform.h @@ -0,0 +1,558 @@ +// Scintilla source code edit control +/** @file Platform.h + ** Interface to platform facilities. Also includes some basic utilities. + ** Implemented in PlatGTK.cxx for GTK+/Linux, PlatWin.cxx for Windows, and PlatWX.cxx for wxWindows. + **/ +// Copyright 1998-2009 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef PLATFORM_H +#define PLATFORM_H + +// PLAT_GTK = GTK+ on Linux or Win32 +// PLAT_GTK_WIN32 is defined additionally when running PLAT_GTK under Win32 +// PLAT_WIN = Win32 API on Win32 OS +// PLAT_WX is wxWindows on any supported platform + +#define PLAT_GTK 0 +#define PLAT_GTK_WIN32 0 +#define PLAT_MACOSX 0 +#define PLAT_WIN 0 +#define PLAT_WX 0 +#define PLAT_FOX 0 + +#if defined(FOX) +#undef PLAT_FOX +#define PLAT_FOX 1 + +#elif defined(__WX__) +#undef PLAT_WX +#define PLAT_WX 1 + +#elif defined(GTK) +#undef PLAT_GTK +#define PLAT_GTK 1 + +#if defined(__WIN32__) || defined(_MSC_VER) +#undef PLAT_GTK_WIN32 +#define PLAT_GTK_WIN32 1 +#endif + +#elif defined(__APPLE__) + +#undef PLAT_MACOSX +#define PLAT_MACOSX 1 + +#else +#undef PLAT_WIN +#define PLAT_WIN 1 + +#endif + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +// Underlying the implementation of the platform classes are platform specific types. +// Sometimes these need to be passed around by client code so they are defined here + +typedef void *FontID; +typedef void *SurfaceID; +typedef void *WindowID; +typedef void *MenuID; +typedef void *TickerID; +typedef void *Function; +typedef void *IdlerID; + +/** + * A geometric point class. + * Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably. + */ +class Point { +public: + int x; + int y; + + explicit Point(int x_=0, int y_=0) : x(x_), y(y_) { + } + + // Other automatically defined methods (assignment, copy constructor, destructor) are fine + + static Point FromLong(long lpoint); +}; + +/** + * A geometric rectangle class. + * PRectangle is exactly the same as the Win32 RECT so can be used interchangeably. + * PRectangles contain their top and left sides, but not their right and bottom sides. + */ +class PRectangle { +public: + int left; + int top; + int right; + int bottom; + + PRectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) : + left(left_), top(top_), right(right_), bottom(bottom_) { + } + + // Other automatically defined methods (assignment, copy constructor, destructor) are fine + + bool operator==(PRectangle &rc) { + return (rc.left == left) && (rc.right == right) && + (rc.top == top) && (rc.bottom == bottom); + } + bool Contains(Point pt) { + return (pt.x >= left) && (pt.x <= right) && + (pt.y >= top) && (pt.y <= bottom); + } + bool Contains(PRectangle rc) { + return (rc.left >= left) && (rc.right <= right) && + (rc.top >= top) && (rc.bottom <= bottom); + } + bool Intersects(PRectangle other) { + return (right > other.left) && (left < other.right) && + (bottom > other.top) && (top < other.bottom); + } + void Move(int xDelta, int yDelta) { + left += xDelta; + top += yDelta; + right += xDelta; + bottom += yDelta; + } + int Width() { return right - left; } + int Height() { return bottom - top; } + bool Empty() { + return (Height() <= 0) || (Width() <= 0); + } +}; + +/** + * In some circumstances, including Win32 in paletted mode and GTK+, each colour + * must be allocated before use. The desired colours are held in the ColourDesired class, + * and after allocation the allocation entry is stored in the ColourAllocated class. In other + * circumstances, such as Win32 in true colour mode, the allocation process just copies + * the RGB values from the desired to the allocated class. + * As each desired colour requires allocation before it can be used, the ColourPair class + * holds both a ColourDesired and a ColourAllocated + * The Palette class is responsible for managing the palette of colours which contains a + * list of ColourPair objects and performs the allocation. + */ + +/** + * Holds a desired RGB colour. + */ +class ColourDesired { + long co; +public: + ColourDesired(long lcol=0) { + co = lcol; + } + + ColourDesired(unsigned int red, unsigned int green, unsigned int blue) { + Set(red, green, blue); + } + + bool operator==(const ColourDesired &other) const { + return co == other.co; + } + + void Set(long lcol) { + co = lcol; + } + + void Set(unsigned int red, unsigned int green, unsigned int blue) { + co = red | (green << 8) | (blue << 16); + } + + static inline unsigned int ValueOfHex(const char ch) { + if (ch >= '0' && ch <= '9') + return ch - '0'; + else if (ch >= 'A' && ch <= 'F') + return ch - 'A' + 10; + else if (ch >= 'a' && ch <= 'f') + return ch - 'a' + 10; + else + return 0; + } + + void Set(const char *val) { + if (*val == '#') { + val++; + } + unsigned int r = ValueOfHex(val[0]) * 16 + ValueOfHex(val[1]); + unsigned int g = ValueOfHex(val[2]) * 16 + ValueOfHex(val[3]); + unsigned int b = ValueOfHex(val[4]) * 16 + ValueOfHex(val[5]); + Set(r, g, b); + } + + long AsLong() const { + return co; + } + + unsigned int GetRed() { + return co & 0xff; + } + + unsigned int GetGreen() { + return (co >> 8) & 0xff; + } + + unsigned int GetBlue() { + return (co >> 16) & 0xff; + } +}; + +/** + * Holds an allocated RGB colour which may be an approximation to the desired colour. + */ +class ColourAllocated { + long coAllocated; + +public: + + ColourAllocated(long lcol=0) { + coAllocated = lcol; + } + + void Set(long lcol) { + coAllocated = lcol; + } + + long AsLong() const { + return coAllocated; + } +}; + +/** + * Colour pairs hold a desired colour and an allocated colour. + */ +struct ColourPair { + ColourDesired desired; + ColourAllocated allocated; + + ColourPair(ColourDesired desired_=ColourDesired(0,0,0)) { + desired = desired_; + allocated.Set(desired.AsLong()); + } + void Copy() { + allocated.Set(desired.AsLong()); + } +}; + +class Window; // Forward declaration for Palette + +/** + * Colour palette management. + */ +class Palette { + int used; + int size; + ColourPair *entries; +#if PLAT_GTK + void *allocatedPalette; // GdkColor * + int allocatedLen; +#endif + // Private so Palette objects can not be copied + Palette(const Palette &) {} + Palette &operator=(const Palette &) { return *this; } +public: +#if PLAT_WIN + void *hpal; +#endif + bool allowRealization; + + Palette(); + ~Palette(); + + void Release(); + + /** + * This method either adds a colour to the list of wanted colours (want==true) + * or retrieves the allocated colour back to the ColourPair. + * This is one method to make it easier to keep the code for wanting and retrieving in sync. + */ + void WantFind(ColourPair &cp, bool want); + + void Allocate(Window &w); +}; + +/** + * Font management. + */ +class Font { +protected: + FontID fid; +#if PLAT_WX + int ascent; +#endif + // Private so Font objects can not be copied + Font(const Font &) {} + Font &operator=(const Font &) { fid=0; return *this; } +public: + Font(); + virtual ~Font(); + + virtual void Create(const char *faceName, int characterSet, int size, + bool bold, bool italic, int extraFontFlag=0); + virtual void Release(); + + FontID GetID() { return fid; } + // Alias another font - caller guarantees not to Release + void SetID(FontID fid_) { fid = fid_; } + friend class Surface; + friend class SurfaceImpl; +}; + +/** + * A surface abstracts a place to draw. + */ +class Surface { +private: + // Private so Surface objects can not be copied + Surface(const Surface &) {} + Surface &operator=(const Surface &) { return *this; } +public: + Surface() {} + virtual ~Surface() {} + static Surface *Allocate(); + + virtual void Init(WindowID wid)=0; + virtual void Init(SurfaceID sid, WindowID wid)=0; + virtual void InitPixMap(int width, int height, Surface *surface_, WindowID wid)=0; + + virtual void Release()=0; + virtual bool Initialised()=0; + virtual void PenColour(ColourAllocated fore)=0; + virtual int LogPixelsY()=0; + virtual int DeviceHeightFont(int points)=0; + virtual void MoveTo(int x_, int y_)=0; + virtual void LineTo(int x_, int y_)=0; + virtual void Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back)=0; + virtual void RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0; + virtual void FillRectangle(PRectangle rc, ColourAllocated back)=0; + virtual void FillRectangle(PRectangle rc, Surface &surfacePattern)=0; + virtual void RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0; + virtual void AlphaRectangle(PRectangle rc, int cornerSize, ColourAllocated fill, int alphaFill, + ColourAllocated outline, int alphaOutline, int flags)=0; + virtual void Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0; + virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource)=0; + + virtual void DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back)=0; + virtual void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back)=0; + virtual void DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore)=0; + virtual void MeasureWidths(Font &font_, const char *s, int len, int *positions)=0; + virtual int WidthText(Font &font_, const char *s, int len)=0; + virtual int WidthChar(Font &font_, char ch)=0; + virtual int Ascent(Font &font_)=0; + virtual int Descent(Font &font_)=0; + virtual int InternalLeading(Font &font_)=0; + virtual int ExternalLeading(Font &font_)=0; + virtual int Height(Font &font_)=0; + virtual int AverageCharWidth(Font &font_)=0; + + virtual int SetPalette(Palette *pal, bool inBackGround)=0; + virtual void SetClip(PRectangle rc)=0; + virtual void FlushCachedState()=0; + + virtual void SetUnicodeMode(bool unicodeMode_)=0; + virtual void SetDBCSMode(int codePage)=0; +}; + +/** + * A simple callback action passing one piece of untyped user data. + */ +typedef void (*CallBackAction)(void*); + +/** + * Class to hide the details of window manipulation. + * Does not own the window which will normally have a longer life than this object. + */ +class Window { +protected: + WindowID wid; +#if PLAT_MACOSX + void *windowRef; + void *control; +#endif +public: + Window() : wid(0), cursorLast(cursorInvalid) { +#if PLAT_MACOSX + windowRef = 0; + control = 0; +#endif + } + Window(const Window &source) : wid(source.wid), cursorLast(cursorInvalid) { +#if PLAT_MACOSX + windowRef = 0; + control = 0; +#endif + } + virtual ~Window(); + Window &operator=(WindowID wid_) { + wid = wid_; + return *this; + } + WindowID GetID() const { return wid; } + bool Created() const { return wid != 0; } + void Destroy(); + bool HasFocus(); + PRectangle GetPosition(); + void SetPosition(PRectangle rc); + void SetPositionRelative(PRectangle rc, Window relativeTo); + PRectangle GetClientPosition(); + void Show(bool show=true); + void InvalidateAll(); + void InvalidateRectangle(PRectangle rc); + virtual void SetFont(Font &font); + enum Cursor { cursorInvalid, cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow, cursorHand }; + void SetCursor(Cursor curs); + void SetTitle(const char *s); + PRectangle GetMonitorRect(Point pt); +#if PLAT_MACOSX + void SetWindow(void *ref) { windowRef = ref; }; + void SetControl(void *_control) { control = _control; }; +#endif +private: + Cursor cursorLast; +}; + +/** + * Listbox management. + */ + +class ListBox : public Window { +public: + ListBox(); + virtual ~ListBox(); + static ListBox *Allocate(); + + virtual void SetFont(Font &font)=0; + virtual void Create(Window &parent, int ctrlID, Point location, int lineHeight_, bool unicodeMode_)=0; + virtual void SetAverageCharWidth(int width)=0; + virtual void SetVisibleRows(int rows)=0; + virtual int GetVisibleRows() const=0; + virtual PRectangle GetDesiredRect()=0; + virtual int CaretFromEdge()=0; + virtual void Clear()=0; + virtual void Append(char *s, int type = -1)=0; + virtual int Length()=0; + virtual void Select(int n)=0; + virtual int GetSelection()=0; + virtual int Find(const char *prefix)=0; + virtual void GetValue(int n, char *value, int len)=0; + virtual void RegisterImage(int type, const char *xpm_data)=0; + virtual void ClearRegisteredImages()=0; + virtual void SetDoubleClickAction(CallBackAction, void *)=0; + virtual void SetList(const char* list, char separator, char typesep)=0; +}; + +/** + * Menu management. + */ +class Menu { + MenuID mid; +public: + Menu(); + MenuID GetID() { return mid; } + void CreatePopUp(); + void Destroy(); + void Show(Point pt, Window &w); +}; + +class ElapsedTime { + long bigBit; + long littleBit; +public: + ElapsedTime(); + double Duration(bool reset=false); +}; + +/** + * Dynamic Library (DLL/SO/...) loading + */ +class DynamicLibrary { +public: + virtual ~DynamicLibrary() {} + + /// @return Pointer to function "name", or NULL on failure. + virtual Function FindFunction(const char *name) = 0; + + /// @return true if the library was loaded successfully. + virtual bool IsValid() = 0; + + /// @return An instance of a DynamicLibrary subclass with "modulePath" loaded. + static DynamicLibrary *Load(const char *modulePath); +}; + +/** + * Platform class used to retrieve system wide parameters such as double click speed + * and chrome colour. Not a creatable object, more of a module with several functions. + */ +class Platform { + // Private so Platform objects can not be copied + Platform(const Platform &) {} + Platform &operator=(const Platform &) { return *this; } +public: + // Should be private because no new Platforms are ever created + // but gcc warns about this + Platform() {} + ~Platform() {} + static ColourDesired Chrome(); + static ColourDesired ChromeHighlight(); + static const char *DefaultFont(); + static int DefaultFontSize(); + static unsigned int DoubleClickTime(); + static bool MouseButtonBounce(); + static void DebugDisplay(const char *s); + static bool IsKeyDown(int key); + static long SendScintilla( + WindowID w, unsigned int msg, unsigned long wParam=0, long lParam=0); + static long SendScintillaPointer( + WindowID w, unsigned int msg, unsigned long wParam=0, void *lParam=0); + static bool IsDBCSLeadByte(int codePage, char ch); + static int DBCSCharLength(int codePage, const char *s); + static int DBCSCharMaxLength(); + + // These are utility functions not really tied to a platform + static int Minimum(int a, int b); + static int Maximum(int a, int b); + // Next three assume 16 bit shorts and 32 bit longs + static long LongFromTwoShorts(short a,short b) { + return (a) | ((b) << 16); + } + static short HighShortFromLong(long x) { + return static_cast(x >> 16); + } + static short LowShortFromLong(long x) { + return static_cast(x & 0xffff); + } + static void DebugPrintf(const char *format, ...); + static bool ShowAssertionPopUps(bool assertionPopUps_); + static void Assert(const char *c, const char *file, int line); + static int Clamp(int val, int minVal, int maxVal); +}; + +//#ifdef NDEBUG +#if 1 +#define PLATFORM_ASSERT(c) ((void)0) +#else + +#ifdef SCI_NAMESPACE +#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Scintilla::Platform::Assert(#c, __FILE__, __LINE__)) +#else +#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Platform::Assert(#c, __FILE__, __LINE__)) +#endif +#endif + +#ifdef SCI_NAMESPACE +} +#endif + +// Shut up annoying Visual C++ warnings: +#ifdef _MSC_VER +#pragma warning(disable: 4244 4309 4514 4710) +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/include/PropSet.h b/sdk/wxscintilla/src/scintilla/include/PropSet.h new file mode 100644 index 0000000..c952021 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/PropSet.h @@ -0,0 +1,26 @@ +// Scintilla source code edit control +/** @file PropSet.h + ** An interface to the methods needed for access to property sets inside lexers. + **/ +// Copyright 1998-2009 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef PROPSET_H +#define PROPSET_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +class PropertyGet { +public: + virtual char *ToString() const=0; // Caller must delete[] the return value + virtual int GetInt(const char *key, int defaultValue=0) const=0; + virtual ~PropertyGet() {} +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/include/SString.h b/sdk/wxscintilla/src/scintilla/include/SString.h new file mode 100644 index 0000000..e376f59 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/SString.h @@ -0,0 +1,289 @@ +// SciTE - Scintilla based Text Editor +/** @file SString.h + ** A simple string class. + **/ +// Copyright 1998-2004 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef SSTRING_H +#define SSTRING_H + + +// These functions are implemented because each platform calls them something different. +int CompareCaseInsensitive(const char *a, const char *b); +int CompareNCaseInsensitive(const char *a, const char *b, size_t len); +bool EqualCaseInsensitive(const char *a, const char *b); + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +// Define another string class. +// While it would be 'better' to use std::string, that doubles the executable size. +// An SString may contain embedded nul characters. + +/** + * Base class from which the two other classes (SBuffer & SString) + * are derived. + */ +class SContainer { +public: + /** Type of string lengths (sizes) and positions (indexes). */ + typedef size_t lenpos_t; + /** Out of bounds value indicating that the string argument should be measured. */ + enum { measure_length=0xffffffffU}; + +protected: + char *s; ///< The C string + lenpos_t sSize; ///< The size of the buffer, less 1: ie. the maximum size of the string + + SContainer() : s(0), sSize(0) {} + ~SContainer() { + delete []s; // Suppose it was allocated using StringAllocate + s = 0; + sSize = 0; + } + /** Size of buffer. */ + lenpos_t size() const { + if (s) { + return sSize; + } else { + return 0; + } + } +public: + /** + * Allocate uninitialized memory big enough to fit a string of the given length. + * @return the pointer to the new string + */ + static char *StringAllocate(lenpos_t len); + /** + * Duplicate a buffer/C string. + * Allocate memory of the given size, or big enough to fit the string if length isn't given; + * then copy the given string in the allocated memory. + * @return the pointer to the new string + */ + static char *StringAllocate( + const char *s, ///< The string to duplicate + lenpos_t len=measure_length); ///< The length of memory to allocate. Optional. +}; + + +/** + * @brief A string buffer class. + * + * Main use is to ask an API the length of a string it can provide, + * then to allocate a buffer of the given size, and to provide this buffer + * to the API to put the string. + * This class is intended to be shortlived, to be transformed as SString + * as soon as it holds the string, so it has little members. + * Note: we assume the buffer is filled by the API. If the length can be shorter, + * we should set sLen to strlen(sb.ptr()) in related SString constructor and assignment. + */ +class SBuffer : protected SContainer { +public: + SBuffer(lenpos_t len) { + s = StringAllocate(len); + if (s) { + *s = '\0'; + sSize = len; + } else { + sSize = 0; + } + } +private: + /// Copy constructor + // Here only to be on the safe size, user should avoid returning SBuffer values. + SBuffer(const SBuffer &source) : SContainer() { + s = StringAllocate(source.s, source.sSize); + sSize = (s) ? source.sSize : 0; + } + /// Default assignment operator + // Same here, shouldn't be used + SBuffer &operator=(const SBuffer &source) { + if (this != &source) { + delete []s; + s = StringAllocate(source.s, source.sSize); + sSize = (s) ? source.sSize : 0; + } + return *this; + } +public: + /** Provide direct read/write access to buffer. */ + char *ptr() { + return s; + } + /** Ownership of the buffer have been taken, so release it. */ + void reset() { + s = 0; + sSize = 0; + } + /** Size of buffer. */ + lenpos_t size() const { + return SContainer::size(); + } +}; + + +/** + * @brief A simple string class. + * + * Hold the length of the string for quick operations, + * can have a buffer bigger than the string to avoid too many memory allocations and copies. + * May have embedded zeroes as a result of @a substitute, but relies too heavily on C string + * functions to allow reliable manipulations of these strings, other than simple appends, etc. + */ +class SString : protected SContainer { + lenpos_t sLen; ///< The size of the string in s + lenpos_t sizeGrowth; ///< Minimum growth size when appending strings + enum { sizeGrowthDefault = 64 }; + + bool grow(lenpos_t lenNew); + SString &assign(const char *sOther, lenpos_t sSize_=measure_length); + +public: + SString() : sLen(0), sizeGrowth(sizeGrowthDefault) {} + SString(const SString &source) : SContainer(), sizeGrowth(sizeGrowthDefault) { + s = StringAllocate(source.s, source.sLen); + sSize = sLen = (s) ? source.sLen : 0; + } + SString(const char *s_) : sizeGrowth(sizeGrowthDefault) { + s = StringAllocate(s_); + sSize = sLen = (s) ? strlen(s) : 0; + } + SString(SBuffer &buf) : sizeGrowth(sizeGrowthDefault) { + s = buf.ptr(); + sSize = sLen = buf.size(); + // Consumes the given buffer! + buf.reset(); + } + SString(const char *s_, lenpos_t first, lenpos_t last) : sizeGrowth(sizeGrowthDefault) { + // note: expects the "last" argument to point one beyond the range end (a la STL iterators) + s = StringAllocate(s_ + first, last - first); + sSize = sLen = (s) ? last - first : 0; + } + SString(int i); + SString(double d, int precision); + ~SString() { + sLen = 0; + } + void clear() { + if (s) { + *s = '\0'; + } + sLen = 0; + } + /** Size of buffer. */ + lenpos_t size() const { + return SContainer::size(); + } + /** Size of string in buffer. */ + lenpos_t length() const { + return sLen; + } + /** Read access to a character of the string. */ + char operator[](lenpos_t i) const { + return (s && i < sSize) ? s[i] : '\0'; + } + SString &operator=(const char *source) { + return assign(source); + } + SString &operator=(const SString &source) { + if (this != &source) { + assign(source.s, source.sLen); + } + return *this; + } + bool operator==(const SString &sOther) const; + bool operator!=(const SString &sOther) const { + return !operator==(sOther); + } + bool operator==(const char *sOther) const; + bool operator!=(const char *sOther) const { + return !operator==(sOther); + } + bool contains(char ch) const { + return (s && *s) ? strchr(s, ch) != 0 : false; + } + void setsizegrowth(lenpos_t sizeGrowth_) { + sizeGrowth = sizeGrowth_; + } + const char *c_str() const { + return s ? s : ""; + } + /** Give ownership of buffer to caller which must use delete[] to free buffer. */ + char *detach() { + char *sRet = s; + s = 0; + sSize = 0; + sLen = 0; + return sRet; + } + SString substr(lenpos_t subPos, lenpos_t subLen=measure_length) const; + SString &lowercase(lenpos_t subPos = 0, lenpos_t subLen=measure_length); + SString &uppercase(lenpos_t subPos = 0, lenpos_t subLen=measure_length); + SString &append(const char *sOther, lenpos_t sLenOther=measure_length, char sep = '\0'); + SString &operator+=(const char *sOther) { + return append(sOther, static_cast(measure_length)); + } + SString &operator+=(const SString &sOther) { + return append(sOther.s, sOther.sLen); + } + SString &operator+=(char ch) { + return append(&ch, 1); + } + SString &appendwithseparator(const char *sOther, char sep) { + return append(sOther, strlen(sOther), sep); + } + SString &insert(lenpos_t pos, const char *sOther, lenpos_t sLenOther=measure_length); + + /** + * Remove @a len characters from the @a pos position, included. + * Characters at pos + len and beyond replace characters at pos. + * If @a len is 0, or greater than the length of the string + * starting at @a pos, the string is just truncated at @a pos. + */ + void remove(lenpos_t pos, lenpos_t len); + + SString &change(lenpos_t pos, char ch) { + if (pos < sLen) { // character changed must be in string bounds + *(s + pos) = ch; + } + return *this; + } + /** Read an integral numeric value from the string. */ + int value() const { + return s ? atoi(s) : 0; + } + bool startswith(const char *prefix); + bool endswith(const char *suffix); + int search(const char *sFind, lenpos_t start=0) const; + bool contains(const char *sFind) const { + return search(sFind) >= 0; + } + int substitute(char chFind, char chReplace); + int substitute(const char *sFind, const char *sReplace); + int remove(const char *sFind) { + return substitute(sFind, ""); + } +}; + + +/** + * Duplicate a C string. + * Allocate memory of the given size, or big enough to fit the string if length isn't given; + * then copy the given string in the allocated memory. + * @return the pointer to the new string + */ +inline char *StringDup( + const char *s, ///< The string to duplicate + SContainer::lenpos_t len=SContainer::measure_length) ///< The length of memory to allocate. Optional. +{ + return SContainer::StringAllocate(s, len); +} + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/include/SciLexer.h b/sdk/wxscintilla/src/scintilla/include/SciLexer.h new file mode 100644 index 0000000..1fd036b --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/SciLexer.h @@ -0,0 +1,1446 @@ +/* Scintilla source code edit control */ +/** @file SciLexer.h + ** Interface to the added lexer functions in the SciLexer version of the edit control. + **/ +/* Copyright 1998-2002 by Neil Hodgson + * The License.txt file describes the conditions under which this software may be distributed. */ + +/* Most of this file is automatically generated from the Scintilla.iface interface definition + * file which contains any comments about the definitions. HFacer.py does the generation. */ + +#ifndef SCILEXER_H +#define SCILEXER_H + +/* SciLexer features - not in standard Scintilla */ + +/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */ +#define SCLEX_CONTAINER 0 +#define SCLEX_NULL 1 +#define SCLEX_PYTHON 2 +#define SCLEX_CPP 3 +#define SCLEX_HTML 4 +#define SCLEX_XML 5 +#define SCLEX_PERL 6 +#define SCLEX_SQL 7 +#define SCLEX_VB 8 +#define SCLEX_PROPERTIES 9 +#define SCLEX_ERRORLIST 10 +#define SCLEX_MAKEFILE 11 +#define SCLEX_BATCH 12 +#define SCLEX_XCODE 13 +#define SCLEX_LATEX 14 +#define SCLEX_LUA 15 +#define SCLEX_DIFF 16 +#define SCLEX_CONF 17 +#define SCLEX_PASCAL 18 +#define SCLEX_AVE 19 +#define SCLEX_ADA 20 +#define SCLEX_LISP 21 +#define SCLEX_RUBY 22 +#define SCLEX_EIFFEL 23 +#define SCLEX_EIFFELKW 24 +#define SCLEX_TCL 25 +#define SCLEX_NNCRONTAB 26 +#define SCLEX_BULLANT 27 +#define SCLEX_VBSCRIPT 28 +#define SCLEX_BAAN 31 +#define SCLEX_MATLAB 32 +#define SCLEX_SCRIPTOL 33 +#define SCLEX_ASM 34 +#define SCLEX_CPPNOCASE 35 +#define SCLEX_FORTRAN 36 +#define SCLEX_F77 37 +#define SCLEX_CSS 38 +#define SCLEX_POV 39 +#define SCLEX_LOUT 40 +#define SCLEX_ESCRIPT 41 +#define SCLEX_PS 42 +#define SCLEX_NSIS 43 +#define SCLEX_MMIXAL 44 +#define SCLEX_CLW 45 +#define SCLEX_CLWNOCASE 46 +#define SCLEX_LOT 47 +#define SCLEX_YAML 48 +#define SCLEX_TEX 49 +#define SCLEX_METAPOST 50 +#define SCLEX_POWERBASIC 51 +#define SCLEX_FORTH 52 +#define SCLEX_ERLANG 53 +#define SCLEX_OCTAVE 54 +#define SCLEX_MSSQL 55 +#define SCLEX_VERILOG 56 +#define SCLEX_KIX 57 +#define SCLEX_GUI4CLI 58 +#define SCLEX_SPECMAN 59 +#define SCLEX_AU3 60 +#define SCLEX_APDL 61 +#define SCLEX_BASH 62 +#define SCLEX_ASN1 63 +#define SCLEX_VHDL 64 +#define SCLEX_CAML 65 +#define SCLEX_BLITZBASIC 66 +#define SCLEX_PUREBASIC 67 +#define SCLEX_HASKELL 68 +#define SCLEX_PHPSCRIPT 69 +#define SCLEX_TADS3 70 +#define SCLEX_REBOL 71 +#define SCLEX_SMALLTALK 72 +#define SCLEX_FLAGSHIP 73 +#define SCLEX_CSOUND 74 +#define SCLEX_FREEBASIC 75 +#define SCLEX_INNOSETUP 76 +#define SCLEX_OPAL 77 +#define SCLEX_SPICE 78 +#define SCLEX_D 79 +#define SCLEX_CMAKE 80 +#define SCLEX_GAP 81 +#define SCLEX_PLM 82 +#define SCLEX_PROGRESS 83 +#define SCLEX_ABAQUS 84 +#define SCLEX_ASYMPTOTE 85 +#define SCLEX_R 86 +#define SCLEX_MAGIK 87 +#define SCLEX_POWERSHELL 88 +#define SCLEX_MYSQL 89 +#define SCLEX_PO 90 +#define SCLEX_TAL 91 +#define SCLEX_COBOL 92 +#define SCLEX_TACL 93 +#define SCLEX_SORCUS 94 +#define SCLEX_POWERPRO 95 +#define SCLEX_NIMROD 96 +#define SCLEX_SML 97 +#define SCLEX_MARKDOWN 98 + +//Eran - START +#define SCLEX_GCC 150 +#define SCLEX_CPPCHECK 153 +#define SCLEX_GCC_DEFAULT 0 +#define SCLEX_GCC_ERROR 1 +#define SCLEX_GCC_WARNING 2 +#define SCLEX_GCC_BUILDING 3 +#define SCLEX_GCC_FILE_LINK 4 +#define SCLEX_GCC_OUTPUT 5 +#define SCLEX_GCC_MAKE_ENTER 6 +#define SCLEX_GCC_MAKE_LEAVING 7 + +#define SCLEX_FIF 151 +#define SCLEX_FIF_DEFAULT 0 +#define SCLEX_FIF_FILE 1 +#define SCLEX_FIF_MATCH 2 +#define SCLEX_FIF_FILE_SHORT 3 +#define SCLEX_FIF_PROJECT 4 +#define SCLEX_FIF_SCOPE 5 + +#define SCLEX_SVN 152 +#define SCLEX_SVN_DEFAULT 0 +#define SCLEX_SVN_UPDATED 1 +#define SCLEX_SVN_CONFLICT 2 +#define SCLEX_SVN_MERGED 3 +#define SCLEX_SVN_DELETED 4 +#define SCLEX_SVN_ADDED 5 +#define SCLEX_SVN_INFO 6 +//Eran - END + +//EPOCH - START +#define SCLEX_ALTARICA 154 +#define SCE_ALTARICA_DEFAULT 0 +#define SCE_ALTARICA_COMMENT 1 +#define SCE_ALTARICA_COMMENTLINE 2 +#define SCE_ALTARICA_KEYWORD 3 +#define SCE_ALTARICA_TYPE 4 +#define SCE_ALTARICA_IDENTIFIER 5 +#define SCE_ALTARICA_OPERATOR 6 +#define SCE_ALTARICA_NUMBER 7 +#define SCE_ALTARICA_FORBIDDEN 8 + +#define SCLEX_PRISM 155 +#define SCE_PRISM_DEFAULT 0 +#define SCE_PRISM_COMMENT 1 +#define SCE_PRISM_KEYWORD 2 +#define SCE_PRISM_FUNCTION 3 +#define SCE_PRISM_TYPE 4 +#define SCE_PRISM_IDENTIFIER 5 +#define SCE_PRISM_OPERATOR 6 +#define SCE_PRISM_NUMBER 7 +#define SCE_PRISM_STRING 8 +#define SCE_PRISM_FORBIDDEN 9 +//EPOCH - END + +#define SCLEX_AUTOMATIC 1000 +#define SCE_P_DEFAULT 0 +#define SCE_P_COMMENTLINE 1 +#define SCE_P_NUMBER 2 +#define SCE_P_STRING 3 +#define SCE_P_CHARACTER 4 +#define SCE_P_WORD 5 +#define SCE_P_TRIPLE 6 +#define SCE_P_TRIPLEDOUBLE 7 +#define SCE_P_CLASSNAME 8 +#define SCE_P_DEFNAME 9 +#define SCE_P_OPERATOR 10 +#define SCE_P_IDENTIFIER 11 +#define SCE_P_COMMENTBLOCK 12 +#define SCE_P_STRINGEOL 13 +#define SCE_P_WORD2 14 +#define SCE_P_DECORATOR 15 +#define SCE_C_DEFAULT 0 +#define SCE_C_COMMENT 1 +#define SCE_C_COMMENTLINE 2 +#define SCE_C_COMMENTDOC 3 +#define SCE_C_NUMBER 4 +#define SCE_C_WORD 5 +#define SCE_C_STRING 6 +#define SCE_C_CHARACTER 7 +#define SCE_C_UUID 8 +#define SCE_C_PREPROCESSOR 9 +#define SCE_C_OPERATOR 10 +#define SCE_C_IDENTIFIER 11 +#define SCE_C_STRINGEOL 12 +#define SCE_C_VERBATIM 13 +#define SCE_C_REGEX 14 +#define SCE_C_COMMENTLINEDOC 15 +#define SCE_C_WORD2 16 +#define SCE_C_COMMENTDOCKEYWORD 17 +#define SCE_C_COMMENTDOCKEYWORDERROR 18 +#define SCE_C_GLOBALCLASS 19 +#define SCE_D_DEFAULT 0 +#define SCE_D_COMMENT 1 +#define SCE_D_COMMENTLINE 2 +#define SCE_D_COMMENTDOC 3 +#define SCE_D_COMMENTNESTED 4 +#define SCE_D_NUMBER 5 +#define SCE_D_WORD 6 +#define SCE_D_WORD2 7 +#define SCE_D_WORD3 8 +#define SCE_D_TYPEDEF 9 +#define SCE_D_STRING 10 +#define SCE_D_STRINGEOL 11 +#define SCE_D_CHARACTER 12 +#define SCE_D_OPERATOR 13 +#define SCE_D_IDENTIFIER 14 +#define SCE_D_COMMENTLINEDOC 15 +#define SCE_D_COMMENTDOCKEYWORD 16 +#define SCE_D_COMMENTDOCKEYWORDERROR 17 +#define SCE_D_STRINGB 18 +#define SCE_D_STRINGR 19 +#define SCE_D_WORD5 20 +#define SCE_D_WORD6 21 +#define SCE_D_WORD7 22 +#define SCE_TCL_DEFAULT 0 +#define SCE_TCL_COMMENT 1 +#define SCE_TCL_COMMENTLINE 2 +#define SCE_TCL_NUMBER 3 +#define SCE_TCL_WORD_IN_QUOTE 4 +#define SCE_TCL_IN_QUOTE 5 +#define SCE_TCL_OPERATOR 6 +#define SCE_TCL_IDENTIFIER 7 +#define SCE_TCL_SUBSTITUTION 8 +#define SCE_TCL_SUB_BRACE 9 +#define SCE_TCL_MODIFIER 10 +#define SCE_TCL_EXPAND 11 +#define SCE_TCL_WORD 12 +#define SCE_TCL_WORD2 13 +#define SCE_TCL_WORD3 14 +#define SCE_TCL_WORD4 15 +#define SCE_TCL_WORD5 16 +#define SCE_TCL_WORD6 17 +#define SCE_TCL_WORD7 18 +#define SCE_TCL_WORD8 19 +#define SCE_TCL_COMMENT_BOX 20 +#define SCE_TCL_BLOCK_COMMENT 21 +#define SCE_H_DEFAULT 0 +#define SCE_H_TAG 1 +#define SCE_H_TAGUNKNOWN 2 +#define SCE_H_ATTRIBUTE 3 +#define SCE_H_ATTRIBUTEUNKNOWN 4 +#define SCE_H_NUMBER 5 +#define SCE_H_DOUBLESTRING 6 +#define SCE_H_SINGLESTRING 7 +#define SCE_H_OTHER 8 +#define SCE_H_COMMENT 9 +#define SCE_H_ENTITY 10 +#define SCE_H_TAGEND 11 +#define SCE_H_XMLSTART 12 +#define SCE_H_XMLEND 13 +#define SCE_H_SCRIPT 14 +#define SCE_H_ASP 15 +#define SCE_H_ASPAT 16 +#define SCE_H_CDATA 17 +#define SCE_H_QUESTION 18 +#define SCE_H_VALUE 19 +#define SCE_H_XCCOMMENT 20 +#define SCE_H_SGML_DEFAULT 21 +#define SCE_H_SGML_COMMAND 22 +#define SCE_H_SGML_1ST_PARAM 23 +#define SCE_H_SGML_DOUBLESTRING 24 +#define SCE_H_SGML_SIMPLESTRING 25 +#define SCE_H_SGML_ERROR 26 +#define SCE_H_SGML_SPECIAL 27 +#define SCE_H_SGML_ENTITY 28 +#define SCE_H_SGML_COMMENT 29 +#define SCE_H_SGML_1ST_PARAM_COMMENT 30 +#define SCE_H_SGML_BLOCK_DEFAULT 31 +#define SCE_HJ_START 40 +#define SCE_HJ_DEFAULT 41 +#define SCE_HJ_COMMENT 42 +#define SCE_HJ_COMMENTLINE 43 +#define SCE_HJ_COMMENTDOC 44 +#define SCE_HJ_NUMBER 45 +#define SCE_HJ_WORD 46 +#define SCE_HJ_KEYWORD 47 +#define SCE_HJ_DOUBLESTRING 48 +#define SCE_HJ_SINGLESTRING 49 +#define SCE_HJ_SYMBOLS 50 +#define SCE_HJ_STRINGEOL 51 +#define SCE_HJ_REGEX 52 +#define SCE_HJA_START 55 +#define SCE_HJA_DEFAULT 56 +#define SCE_HJA_COMMENT 57 +#define SCE_HJA_COMMENTLINE 58 +#define SCE_HJA_COMMENTDOC 59 +#define SCE_HJA_NUMBER 60 +#define SCE_HJA_WORD 61 +#define SCE_HJA_KEYWORD 62 +#define SCE_HJA_DOUBLESTRING 63 +#define SCE_HJA_SINGLESTRING 64 +#define SCE_HJA_SYMBOLS 65 +#define SCE_HJA_STRINGEOL 66 +#define SCE_HJA_REGEX 67 +#define SCE_HB_START 70 +#define SCE_HB_DEFAULT 71 +#define SCE_HB_COMMENTLINE 72 +#define SCE_HB_NUMBER 73 +#define SCE_HB_WORD 74 +#define SCE_HB_STRING 75 +#define SCE_HB_IDENTIFIER 76 +#define SCE_HB_STRINGEOL 77 +#define SCE_HBA_START 80 +#define SCE_HBA_DEFAULT 81 +#define SCE_HBA_COMMENTLINE 82 +#define SCE_HBA_NUMBER 83 +#define SCE_HBA_WORD 84 +#define SCE_HBA_STRING 85 +#define SCE_HBA_IDENTIFIER 86 +#define SCE_HBA_STRINGEOL 87 +#define SCE_HP_START 90 +#define SCE_HP_DEFAULT 91 +#define SCE_HP_COMMENTLINE 92 +#define SCE_HP_NUMBER 93 +#define SCE_HP_STRING 94 +#define SCE_HP_CHARACTER 95 +#define SCE_HP_WORD 96 +#define SCE_HP_TRIPLE 97 +#define SCE_HP_TRIPLEDOUBLE 98 +#define SCE_HP_CLASSNAME 99 +#define SCE_HP_DEFNAME 100 +#define SCE_HP_OPERATOR 101 +#define SCE_HP_IDENTIFIER 102 +#define SCE_HPHP_COMPLEX_VARIABLE 104 +#define SCE_HPA_START 105 +#define SCE_HPA_DEFAULT 106 +#define SCE_HPA_COMMENTLINE 107 +#define SCE_HPA_NUMBER 108 +#define SCE_HPA_STRING 109 +#define SCE_HPA_CHARACTER 110 +#define SCE_HPA_WORD 111 +#define SCE_HPA_TRIPLE 112 +#define SCE_HPA_TRIPLEDOUBLE 113 +#define SCE_HPA_CLASSNAME 114 +#define SCE_HPA_DEFNAME 115 +#define SCE_HPA_OPERATOR 116 +#define SCE_HPA_IDENTIFIER 117 +#define SCE_HPHP_DEFAULT 118 +#define SCE_HPHP_HSTRING 119 +#define SCE_HPHP_SIMPLESTRING 120 +#define SCE_HPHP_WORD 121 +#define SCE_HPHP_NUMBER 122 +#define SCE_HPHP_VARIABLE 123 +#define SCE_HPHP_COMMENT 124 +#define SCE_HPHP_COMMENTLINE 125 +#define SCE_HPHP_HSTRING_VARIABLE 126 +#define SCE_HPHP_OPERATOR 127 +#define SCE_PL_DEFAULT 0 +#define SCE_PL_ERROR 1 +#define SCE_PL_COMMENTLINE 2 +#define SCE_PL_POD 3 +#define SCE_PL_NUMBER 4 +#define SCE_PL_WORD 5 +#define SCE_PL_STRING 6 +#define SCE_PL_CHARACTER 7 +#define SCE_PL_PUNCTUATION 8 +#define SCE_PL_PREPROCESSOR 9 +#define SCE_PL_OPERATOR 10 +#define SCE_PL_IDENTIFIER 11 +#define SCE_PL_SCALAR 12 +#define SCE_PL_ARRAY 13 +#define SCE_PL_HASH 14 +#define SCE_PL_SYMBOLTABLE 15 +#define SCE_PL_VARIABLE_INDEXER 16 +#define SCE_PL_REGEX 17 +#define SCE_PL_REGSUBST 18 +#define SCE_PL_LONGQUOTE 19 +#define SCE_PL_BACKTICKS 20 +#define SCE_PL_DATASECTION 21 +#define SCE_PL_HERE_DELIM 22 +#define SCE_PL_HERE_Q 23 +#define SCE_PL_HERE_QQ 24 +#define SCE_PL_HERE_QX 25 +#define SCE_PL_STRING_Q 26 +#define SCE_PL_STRING_QQ 27 +#define SCE_PL_STRING_QX 28 +#define SCE_PL_STRING_QR 29 +#define SCE_PL_STRING_QW 30 +#define SCE_PL_POD_VERB 31 +#define SCE_PL_SUB_PROTOTYPE 40 +#define SCE_PL_FORMAT_IDENT 41 +#define SCE_PL_FORMAT 42 +#define SCE_RB_DEFAULT 0 +#define SCE_RB_ERROR 1 +#define SCE_RB_COMMENTLINE 2 +#define SCE_RB_POD 3 +#define SCE_RB_NUMBER 4 +#define SCE_RB_WORD 5 +#define SCE_RB_STRING 6 +#define SCE_RB_CHARACTER 7 +#define SCE_RB_CLASSNAME 8 +#define SCE_RB_DEFNAME 9 +#define SCE_RB_OPERATOR 10 +#define SCE_RB_IDENTIFIER 11 +#define SCE_RB_REGEX 12 +#define SCE_RB_GLOBAL 13 +#define SCE_RB_SYMBOL 14 +#define SCE_RB_MODULE_NAME 15 +#define SCE_RB_INSTANCE_VAR 16 +#define SCE_RB_CLASS_VAR 17 +#define SCE_RB_BACKTICKS 18 +#define SCE_RB_DATASECTION 19 +#define SCE_RB_HERE_DELIM 20 +#define SCE_RB_HERE_Q 21 +#define SCE_RB_HERE_QQ 22 +#define SCE_RB_HERE_QX 23 +#define SCE_RB_STRING_Q 24 +#define SCE_RB_STRING_QQ 25 +#define SCE_RB_STRING_QX 26 +#define SCE_RB_STRING_QR 27 +#define SCE_RB_STRING_QW 28 +#define SCE_RB_WORD_DEMOTED 29 +#define SCE_RB_STDIN 30 +#define SCE_RB_STDOUT 31 +#define SCE_RB_STDERR 40 +#define SCE_RB_UPPER_BOUND 41 +#define SCE_B_DEFAULT 0 +#define SCE_B_COMMENT 1 +#define SCE_B_NUMBER 2 +#define SCE_B_KEYWORD 3 +#define SCE_B_STRING 4 +#define SCE_B_PREPROCESSOR 5 +#define SCE_B_OPERATOR 6 +#define SCE_B_IDENTIFIER 7 +#define SCE_B_DATE 8 +#define SCE_B_STRINGEOL 9 +#define SCE_B_KEYWORD2 10 +#define SCE_B_KEYWORD3 11 +#define SCE_B_KEYWORD4 12 +#define SCE_B_CONSTANT 13 +#define SCE_B_ASM 14 +#define SCE_B_LABEL 15 +#define SCE_B_ERROR 16 +#define SCE_B_HEXNUMBER 17 +#define SCE_B_BINNUMBER 18 +#define SCE_PROPS_DEFAULT 0 +#define SCE_PROPS_COMMENT 1 +#define SCE_PROPS_SECTION 2 +#define SCE_PROPS_ASSIGNMENT 3 +#define SCE_PROPS_DEFVAL 4 +#define SCE_PROPS_KEY 5 +#define SCE_L_DEFAULT 0 +#define SCE_L_COMMAND 1 +#define SCE_L_TAG 2 +#define SCE_L_MATH 3 +#define SCE_L_COMMENT 4 +#define SCE_LUA_DEFAULT 0 +#define SCE_LUA_COMMENT 1 +#define SCE_LUA_COMMENTLINE 2 +#define SCE_LUA_COMMENTDOC 3 +#define SCE_LUA_NUMBER 4 +#define SCE_LUA_WORD 5 +#define SCE_LUA_STRING 6 +#define SCE_LUA_CHARACTER 7 +#define SCE_LUA_LITERALSTRING 8 +#define SCE_LUA_PREPROCESSOR 9 +#define SCE_LUA_OPERATOR 10 +#define SCE_LUA_IDENTIFIER 11 +#define SCE_LUA_STRINGEOL 12 +#define SCE_LUA_WORD2 13 +#define SCE_LUA_WORD3 14 +#define SCE_LUA_WORD4 15 +#define SCE_LUA_WORD5 16 +#define SCE_LUA_WORD6 17 +#define SCE_LUA_WORD7 18 +#define SCE_LUA_WORD8 19 +#define SCE_ERR_DEFAULT 0 +#define SCE_ERR_PYTHON 1 +#define SCE_ERR_GCC 2 +#define SCE_ERR_MS 3 +#define SCE_ERR_CMD 4 +#define SCE_ERR_BORLAND 5 +#define SCE_ERR_PERL 6 +#define SCE_ERR_NET 7 +#define SCE_ERR_LUA 8 +#define SCE_ERR_CTAG 9 +#define SCE_ERR_DIFF_CHANGED 10 +#define SCE_ERR_DIFF_ADDITION 11 +#define SCE_ERR_DIFF_DELETION 12 +#define SCE_ERR_DIFF_MESSAGE 13 +#define SCE_ERR_PHP 14 +#define SCE_ERR_ELF 15 +#define SCE_ERR_IFC 16 +#define SCE_ERR_IFORT 17 +#define SCE_ERR_ABSF 18 +#define SCE_ERR_TIDY 19 +#define SCE_ERR_JAVA_STACK 20 +#define SCE_ERR_VALUE 21 +#define SCE_BAT_DEFAULT 0 +#define SCE_BAT_COMMENT 1 +#define SCE_BAT_WORD 2 +#define SCE_BAT_LABEL 3 +#define SCE_BAT_HIDE 4 +#define SCE_BAT_COMMAND 5 +#define SCE_BAT_IDENTIFIER 6 +#define SCE_BAT_OPERATOR 7 +#define SCE_MAKE_DEFAULT 0 +#define SCE_MAKE_COMMENT 1 +#define SCE_MAKE_PREPROCESSOR 2 +#define SCE_MAKE_IDENTIFIER 3 +#define SCE_MAKE_OPERATOR 4 +#define SCE_MAKE_TARGET 5 +#define SCE_MAKE_IDEOL 9 +#define SCE_DIFF_DEFAULT 0 +#define SCE_DIFF_COMMENT 1 +#define SCE_DIFF_COMMAND 2 +#define SCE_DIFF_HEADER 3 +#define SCE_DIFF_POSITION 4 +#define SCE_DIFF_DELETED 5 +#define SCE_DIFF_ADDED 6 +#define SCE_DIFF_CHANGED 7 +#define SCE_CONF_DEFAULT 0 +#define SCE_CONF_COMMENT 1 +#define SCE_CONF_NUMBER 2 +#define SCE_CONF_IDENTIFIER 3 +#define SCE_CONF_EXTENSION 4 +#define SCE_CONF_PARAMETER 5 +#define SCE_CONF_STRING 6 +#define SCE_CONF_OPERATOR 7 +#define SCE_CONF_IP 8 +#define SCE_CONF_DIRECTIVE 9 +#define SCE_AVE_DEFAULT 0 +#define SCE_AVE_COMMENT 1 +#define SCE_AVE_NUMBER 2 +#define SCE_AVE_WORD 3 +#define SCE_AVE_STRING 6 +#define SCE_AVE_ENUM 7 +#define SCE_AVE_STRINGEOL 8 +#define SCE_AVE_IDENTIFIER 9 +#define SCE_AVE_OPERATOR 10 +#define SCE_AVE_WORD1 11 +#define SCE_AVE_WORD2 12 +#define SCE_AVE_WORD3 13 +#define SCE_AVE_WORD4 14 +#define SCE_AVE_WORD5 15 +#define SCE_AVE_WORD6 16 +#define SCE_ADA_DEFAULT 0 +#define SCE_ADA_WORD 1 +#define SCE_ADA_IDENTIFIER 2 +#define SCE_ADA_NUMBER 3 +#define SCE_ADA_DELIMITER 4 +#define SCE_ADA_CHARACTER 5 +#define SCE_ADA_CHARACTEREOL 6 +#define SCE_ADA_STRING 7 +#define SCE_ADA_STRINGEOL 8 +#define SCE_ADA_LABEL 9 +#define SCE_ADA_COMMENTLINE 10 +#define SCE_ADA_ILLEGAL 11 +#define SCE_BAAN_DEFAULT 0 +#define SCE_BAAN_COMMENT 1 +#define SCE_BAAN_COMMENTDOC 2 +#define SCE_BAAN_NUMBER 3 +#define SCE_BAAN_WORD 4 +#define SCE_BAAN_STRING 5 +#define SCE_BAAN_PREPROCESSOR 6 +#define SCE_BAAN_OPERATOR 7 +#define SCE_BAAN_IDENTIFIER 8 +#define SCE_BAAN_STRINGEOL 9 +#define SCE_BAAN_WORD2 10 +#define SCE_LISP_DEFAULT 0 +#define SCE_LISP_COMMENT 1 +#define SCE_LISP_NUMBER 2 +#define SCE_LISP_KEYWORD 3 +#define SCE_LISP_KEYWORD_KW 4 +#define SCE_LISP_SYMBOL 5 +#define SCE_LISP_STRING 6 +#define SCE_LISP_STRINGEOL 8 +#define SCE_LISP_IDENTIFIER 9 +#define SCE_LISP_OPERATOR 10 +#define SCE_LISP_SPECIAL 11 +#define SCE_LISP_MULTI_COMMENT 12 +#define SCE_EIFFEL_DEFAULT 0 +#define SCE_EIFFEL_COMMENTLINE 1 +#define SCE_EIFFEL_NUMBER 2 +#define SCE_EIFFEL_WORD 3 +#define SCE_EIFFEL_STRING 4 +#define SCE_EIFFEL_CHARACTER 5 +#define SCE_EIFFEL_OPERATOR 6 +#define SCE_EIFFEL_IDENTIFIER 7 +#define SCE_EIFFEL_STRINGEOL 8 +#define SCE_NNCRONTAB_DEFAULT 0 +#define SCE_NNCRONTAB_COMMENT 1 +#define SCE_NNCRONTAB_TASK 2 +#define SCE_NNCRONTAB_SECTION 3 +#define SCE_NNCRONTAB_KEYWORD 4 +#define SCE_NNCRONTAB_MODIFIER 5 +#define SCE_NNCRONTAB_ASTERISK 6 +#define SCE_NNCRONTAB_NUMBER 7 +#define SCE_NNCRONTAB_STRING 8 +#define SCE_NNCRONTAB_ENVIRONMENT 9 +#define SCE_NNCRONTAB_IDENTIFIER 10 +#define SCE_FORTH_DEFAULT 0 +#define SCE_FORTH_COMMENT 1 +#define SCE_FORTH_COMMENT_ML 2 +#define SCE_FORTH_IDENTIFIER 3 +#define SCE_FORTH_CONTROL 4 +#define SCE_FORTH_KEYWORD 5 +#define SCE_FORTH_DEFWORD 6 +#define SCE_FORTH_PREWORD1 7 +#define SCE_FORTH_PREWORD2 8 +#define SCE_FORTH_NUMBER 9 +#define SCE_FORTH_STRING 10 +#define SCE_FORTH_LOCALE 11 +#define SCE_MATLAB_DEFAULT 0 +#define SCE_MATLAB_COMMENT 1 +#define SCE_MATLAB_COMMAND 2 +#define SCE_MATLAB_NUMBER 3 +#define SCE_MATLAB_KEYWORD 4 +#define SCE_MATLAB_STRING 5 +#define SCE_MATLAB_OPERATOR 6 +#define SCE_MATLAB_IDENTIFIER 7 +#define SCE_MATLAB_DOUBLEQUOTESTRING 8 +#define SCE_SCRIPTOL_DEFAULT 0 +#define SCE_SCRIPTOL_WHITE 1 +#define SCE_SCRIPTOL_COMMENTLINE 2 +#define SCE_SCRIPTOL_PERSISTENT 3 +#define SCE_SCRIPTOL_CSTYLE 4 +#define SCE_SCRIPTOL_COMMENTBLOCK 5 +#define SCE_SCRIPTOL_NUMBER 6 +#define SCE_SCRIPTOL_STRING 7 +#define SCE_SCRIPTOL_CHARACTER 8 +#define SCE_SCRIPTOL_STRINGEOL 9 +#define SCE_SCRIPTOL_KEYWORD 10 +#define SCE_SCRIPTOL_OPERATOR 11 +#define SCE_SCRIPTOL_IDENTIFIER 12 +#define SCE_SCRIPTOL_TRIPLE 13 +#define SCE_SCRIPTOL_CLASSNAME 14 +#define SCE_SCRIPTOL_PREPROCESSOR 15 +#define SCE_ASM_DEFAULT 0 +#define SCE_ASM_COMMENT 1 +#define SCE_ASM_NUMBER 2 +#define SCE_ASM_STRING 3 +#define SCE_ASM_OPERATOR 4 +#define SCE_ASM_IDENTIFIER 5 +#define SCE_ASM_CPUINSTRUCTION 6 +#define SCE_ASM_MATHINSTRUCTION 7 +#define SCE_ASM_REGISTER 8 +#define SCE_ASM_DIRECTIVE 9 +#define SCE_ASM_DIRECTIVEOPERAND 10 +#define SCE_ASM_COMMENTBLOCK 11 +#define SCE_ASM_CHARACTER 12 +#define SCE_ASM_STRINGEOL 13 +#define SCE_ASM_EXTINSTRUCTION 14 +#define SCE_F_DEFAULT 0 +#define SCE_F_COMMENT 1 +#define SCE_F_NUMBER 2 +#define SCE_F_STRING1 3 +#define SCE_F_STRING2 4 +#define SCE_F_STRINGEOL 5 +#define SCE_F_OPERATOR 6 +#define SCE_F_IDENTIFIER 7 +#define SCE_F_WORD 8 +#define SCE_F_WORD2 9 +#define SCE_F_WORD3 10 +#define SCE_F_PREPROCESSOR 11 +#define SCE_F_OPERATOR2 12 +#define SCE_F_LABEL 13 +#define SCE_F_CONTINUATION 14 +#define SCE_CSS_DEFAULT 0 +#define SCE_CSS_TAG 1 +#define SCE_CSS_CLASS 2 +#define SCE_CSS_PSEUDOCLASS 3 +#define SCE_CSS_UNKNOWN_PSEUDOCLASS 4 +#define SCE_CSS_OPERATOR 5 +#define SCE_CSS_IDENTIFIER 6 +#define SCE_CSS_UNKNOWN_IDENTIFIER 7 +#define SCE_CSS_VALUE 8 +#define SCE_CSS_COMMENT 9 +#define SCE_CSS_ID 10 +#define SCE_CSS_IMPORTANT 11 +#define SCE_CSS_DIRECTIVE 12 +#define SCE_CSS_DOUBLESTRING 13 +#define SCE_CSS_SINGLESTRING 14 +#define SCE_CSS_IDENTIFIER2 15 +#define SCE_CSS_ATTRIBUTE 16 +#define SCE_CSS_IDENTIFIER3 17 +#define SCE_CSS_PSEUDOELEMENT 18 +#define SCE_CSS_EXTENDED_IDENTIFIER 19 +#define SCE_CSS_EXTENDED_PSEUDOCLASS 20 +#define SCE_CSS_EXTENDED_PSEUDOELEMENT 21 +#define SCE_CSS_MEDIA 22 +#define SCE_POV_DEFAULT 0 +#define SCE_POV_COMMENT 1 +#define SCE_POV_COMMENTLINE 2 +#define SCE_POV_NUMBER 3 +#define SCE_POV_OPERATOR 4 +#define SCE_POV_IDENTIFIER 5 +#define SCE_POV_STRING 6 +#define SCE_POV_STRINGEOL 7 +#define SCE_POV_DIRECTIVE 8 +#define SCE_POV_BADDIRECTIVE 9 +#define SCE_POV_WORD2 10 +#define SCE_POV_WORD3 11 +#define SCE_POV_WORD4 12 +#define SCE_POV_WORD5 13 +#define SCE_POV_WORD6 14 +#define SCE_POV_WORD7 15 +#define SCE_POV_WORD8 16 +#define SCE_LOUT_DEFAULT 0 +#define SCE_LOUT_COMMENT 1 +#define SCE_LOUT_NUMBER 2 +#define SCE_LOUT_WORD 3 +#define SCE_LOUT_WORD2 4 +#define SCE_LOUT_WORD3 5 +#define SCE_LOUT_WORD4 6 +#define SCE_LOUT_STRING 7 +#define SCE_LOUT_OPERATOR 8 +#define SCE_LOUT_IDENTIFIER 9 +#define SCE_LOUT_STRINGEOL 10 +#define SCE_ESCRIPT_DEFAULT 0 +#define SCE_ESCRIPT_COMMENT 1 +#define SCE_ESCRIPT_COMMENTLINE 2 +#define SCE_ESCRIPT_COMMENTDOC 3 +#define SCE_ESCRIPT_NUMBER 4 +#define SCE_ESCRIPT_WORD 5 +#define SCE_ESCRIPT_STRING 6 +#define SCE_ESCRIPT_OPERATOR 7 +#define SCE_ESCRIPT_IDENTIFIER 8 +#define SCE_ESCRIPT_BRACE 9 +#define SCE_ESCRIPT_WORD2 10 +#define SCE_ESCRIPT_WORD3 11 +#define SCE_PS_DEFAULT 0 +#define SCE_PS_COMMENT 1 +#define SCE_PS_DSC_COMMENT 2 +#define SCE_PS_DSC_VALUE 3 +#define SCE_PS_NUMBER 4 +#define SCE_PS_NAME 5 +#define SCE_PS_KEYWORD 6 +#define SCE_PS_LITERAL 7 +#define SCE_PS_IMMEVAL 8 +#define SCE_PS_PAREN_ARRAY 9 +#define SCE_PS_PAREN_DICT 10 +#define SCE_PS_PAREN_PROC 11 +#define SCE_PS_TEXT 12 +#define SCE_PS_HEXSTRING 13 +#define SCE_PS_BASE85STRING 14 +#define SCE_PS_BADSTRINGCHAR 15 +#define SCE_NSIS_DEFAULT 0 +#define SCE_NSIS_COMMENT 1 +#define SCE_NSIS_STRINGDQ 2 +#define SCE_NSIS_STRINGLQ 3 +#define SCE_NSIS_STRINGRQ 4 +#define SCE_NSIS_FUNCTION 5 +#define SCE_NSIS_VARIABLE 6 +#define SCE_NSIS_LABEL 7 +#define SCE_NSIS_USERDEFINED 8 +#define SCE_NSIS_SECTIONDEF 9 +#define SCE_NSIS_SUBSECTIONDEF 10 +#define SCE_NSIS_IFDEFINEDEF 11 +#define SCE_NSIS_MACRODEF 12 +#define SCE_NSIS_STRINGVAR 13 +#define SCE_NSIS_NUMBER 14 +#define SCE_NSIS_SECTIONGROUP 15 +#define SCE_NSIS_PAGEEX 16 +#define SCE_NSIS_FUNCTIONDEF 17 +#define SCE_NSIS_COMMENTBOX 18 +#define SCE_MMIXAL_LEADWS 0 +#define SCE_MMIXAL_COMMENT 1 +#define SCE_MMIXAL_LABEL 2 +#define SCE_MMIXAL_OPCODE 3 +#define SCE_MMIXAL_OPCODE_PRE 4 +#define SCE_MMIXAL_OPCODE_VALID 5 +#define SCE_MMIXAL_OPCODE_UNKNOWN 6 +#define SCE_MMIXAL_OPCODE_POST 7 +#define SCE_MMIXAL_OPERANDS 8 +#define SCE_MMIXAL_NUMBER 9 +#define SCE_MMIXAL_REF 10 +#define SCE_MMIXAL_CHAR 11 +#define SCE_MMIXAL_STRING 12 +#define SCE_MMIXAL_REGISTER 13 +#define SCE_MMIXAL_HEX 14 +#define SCE_MMIXAL_OPERATOR 15 +#define SCE_MMIXAL_SYMBOL 16 +#define SCE_MMIXAL_INCLUDE 17 +#define SCE_CLW_DEFAULT 0 +#define SCE_CLW_LABEL 1 +#define SCE_CLW_COMMENT 2 +#define SCE_CLW_STRING 3 +#define SCE_CLW_USER_IDENTIFIER 4 +#define SCE_CLW_INTEGER_CONSTANT 5 +#define SCE_CLW_REAL_CONSTANT 6 +#define SCE_CLW_PICTURE_STRING 7 +#define SCE_CLW_KEYWORD 8 +#define SCE_CLW_COMPILER_DIRECTIVE 9 +#define SCE_CLW_RUNTIME_EXPRESSIONS 10 +#define SCE_CLW_BUILTIN_PROCEDURES_FUNCTION 11 +#define SCE_CLW_STRUCTURE_DATA_TYPE 12 +#define SCE_CLW_ATTRIBUTE 13 +#define SCE_CLW_STANDARD_EQUATE 14 +#define SCE_CLW_ERROR 15 +#define SCE_CLW_DEPRECATED 16 +#define SCE_LOT_DEFAULT 0 +#define SCE_LOT_HEADER 1 +#define SCE_LOT_BREAK 2 +#define SCE_LOT_SET 3 +#define SCE_LOT_PASS 4 +#define SCE_LOT_FAIL 5 +#define SCE_LOT_ABORT 6 +#define SCE_YAML_DEFAULT 0 +#define SCE_YAML_COMMENT 1 +#define SCE_YAML_IDENTIFIER 2 +#define SCE_YAML_KEYWORD 3 +#define SCE_YAML_NUMBER 4 +#define SCE_YAML_REFERENCE 5 +#define SCE_YAML_DOCUMENT 6 +#define SCE_YAML_TEXT 7 +#define SCE_YAML_ERROR 8 +#define SCE_YAML_OPERATOR 9 +#define SCE_TEX_DEFAULT 0 +#define SCE_TEX_SPECIAL 1 +#define SCE_TEX_GROUP 2 +#define SCE_TEX_SYMBOL 3 +#define SCE_TEX_COMMAND 4 +#define SCE_TEX_TEXT 5 +#define SCE_METAPOST_DEFAULT 0 +#define SCE_METAPOST_SPECIAL 1 +#define SCE_METAPOST_GROUP 2 +#define SCE_METAPOST_SYMBOL 3 +#define SCE_METAPOST_COMMAND 4 +#define SCE_METAPOST_TEXT 5 +#define SCE_METAPOST_EXTRA 6 +#define SCE_ERLANG_DEFAULT 0 +#define SCE_ERLANG_COMMENT 1 +#define SCE_ERLANG_VARIABLE 2 +#define SCE_ERLANG_NUMBER 3 +#define SCE_ERLANG_KEYWORD 4 +#define SCE_ERLANG_STRING 5 +#define SCE_ERLANG_OPERATOR 6 +#define SCE_ERLANG_ATOM 7 +#define SCE_ERLANG_FUNCTION_NAME 8 +#define SCE_ERLANG_CHARACTER 9 +#define SCE_ERLANG_MACRO 10 +#define SCE_ERLANG_RECORD 11 +#define SCE_ERLANG_PREPROC 12 +#define SCE_ERLANG_NODE_NAME 13 +#define SCE_ERLANG_COMMENT_FUNCTION 14 +#define SCE_ERLANG_COMMENT_MODULE 15 +#define SCE_ERLANG_COMMENT_DOC 16 +#define SCE_ERLANG_COMMENT_DOC_MACRO 17 +#define SCE_ERLANG_ATOM_QUOTED 18 +#define SCE_ERLANG_MACRO_QUOTED 19 +#define SCE_ERLANG_RECORD_QUOTED 20 +#define SCE_ERLANG_NODE_NAME_QUOTED 21 +#define SCE_ERLANG_BIFS 22 +#define SCE_ERLANG_MODULES 23 +#define SCE_ERLANG_MODULES_ATT 24 +#define SCE_ERLANG_UNKNOWN 31 +#define SCE_MSSQL_DEFAULT 0 +#define SCE_MSSQL_COMMENT 1 +#define SCE_MSSQL_LINE_COMMENT 2 +#define SCE_MSSQL_NUMBER 3 +#define SCE_MSSQL_STRING 4 +#define SCE_MSSQL_OPERATOR 5 +#define SCE_MSSQL_IDENTIFIER 6 +#define SCE_MSSQL_VARIABLE 7 +#define SCE_MSSQL_COLUMN_NAME 8 +#define SCE_MSSQL_STATEMENT 9 +#define SCE_MSSQL_DATATYPE 10 +#define SCE_MSSQL_SYSTABLE 11 +#define SCE_MSSQL_GLOBAL_VARIABLE 12 +#define SCE_MSSQL_FUNCTION 13 +#define SCE_MSSQL_STORED_PROCEDURE 14 +#define SCE_MSSQL_DEFAULT_PREF_DATATYPE 15 +#define SCE_MSSQL_COLUMN_NAME_2 16 +#define SCE_V_DEFAULT 0 +#define SCE_V_COMMENT 1 +#define SCE_V_COMMENTLINE 2 +#define SCE_V_COMMENTLINEBANG 3 +#define SCE_V_NUMBER 4 +#define SCE_V_WORD 5 +#define SCE_V_STRING 6 +#define SCE_V_WORD2 7 +#define SCE_V_WORD3 8 +#define SCE_V_PREPROCESSOR 9 +#define SCE_V_OPERATOR 10 +#define SCE_V_IDENTIFIER 11 +#define SCE_V_STRINGEOL 12 +#define SCE_V_USER 19 +#define SCE_KIX_DEFAULT 0 +#define SCE_KIX_COMMENT 1 +#define SCE_KIX_STRING1 2 +#define SCE_KIX_STRING2 3 +#define SCE_KIX_NUMBER 4 +#define SCE_KIX_VAR 5 +#define SCE_KIX_MACRO 6 +#define SCE_KIX_KEYWORD 7 +#define SCE_KIX_FUNCTIONS 8 +#define SCE_KIX_OPERATOR 9 +#define SCE_KIX_IDENTIFIER 31 +#define SCE_GC_DEFAULT 0 +#define SCE_GC_COMMENTLINE 1 +#define SCE_GC_COMMENTBLOCK 2 +#define SCE_GC_GLOBAL 3 +#define SCE_GC_EVENT 4 +#define SCE_GC_ATTRIBUTE 5 +#define SCE_GC_CONTROL 6 +#define SCE_GC_COMMAND 7 +#define SCE_GC_STRING 8 +#define SCE_GC_OPERATOR 9 +#define SCE_SN_DEFAULT 0 +#define SCE_SN_CODE 1 +#define SCE_SN_COMMENTLINE 2 +#define SCE_SN_COMMENTLINEBANG 3 +#define SCE_SN_NUMBER 4 +#define SCE_SN_WORD 5 +#define SCE_SN_STRING 6 +#define SCE_SN_WORD2 7 +#define SCE_SN_WORD3 8 +#define SCE_SN_PREPROCESSOR 9 +#define SCE_SN_OPERATOR 10 +#define SCE_SN_IDENTIFIER 11 +#define SCE_SN_STRINGEOL 12 +#define SCE_SN_REGEXTAG 13 +#define SCE_SN_SIGNAL 14 +#define SCE_SN_USER 19 +#define SCE_AU3_DEFAULT 0 +#define SCE_AU3_COMMENT 1 +#define SCE_AU3_COMMENTBLOCK 2 +#define SCE_AU3_NUMBER 3 +#define SCE_AU3_FUNCTION 4 +#define SCE_AU3_KEYWORD 5 +#define SCE_AU3_MACRO 6 +#define SCE_AU3_STRING 7 +#define SCE_AU3_OPERATOR 8 +#define SCE_AU3_VARIABLE 9 +#define SCE_AU3_SENT 10 +#define SCE_AU3_PREPROCESSOR 11 +#define SCE_AU3_SPECIAL 12 +#define SCE_AU3_EXPAND 13 +#define SCE_AU3_COMOBJ 14 +#define SCE_AU3_UDF 15 +#define SCE_APDL_DEFAULT 0 +#define SCE_APDL_COMMENT 1 +#define SCE_APDL_COMMENTBLOCK 2 +#define SCE_APDL_NUMBER 3 +#define SCE_APDL_STRING 4 +#define SCE_APDL_OPERATOR 5 +#define SCE_APDL_WORD 6 +#define SCE_APDL_PROCESSOR 7 +#define SCE_APDL_COMMAND 8 +#define SCE_APDL_SLASHCOMMAND 9 +#define SCE_APDL_STARCOMMAND 10 +#define SCE_APDL_ARGUMENT 11 +#define SCE_APDL_FUNCTION 12 +#define SCE_SH_DEFAULT 0 +#define SCE_SH_ERROR 1 +#define SCE_SH_COMMENTLINE 2 +#define SCE_SH_NUMBER 3 +#define SCE_SH_WORD 4 +#define SCE_SH_STRING 5 +#define SCE_SH_CHARACTER 6 +#define SCE_SH_OPERATOR 7 +#define SCE_SH_IDENTIFIER 8 +#define SCE_SH_SCALAR 9 +#define SCE_SH_PARAM 10 +#define SCE_SH_BACKTICKS 11 +#define SCE_SH_HERE_DELIM 12 +#define SCE_SH_HERE_Q 13 +#define SCE_ASN1_DEFAULT 0 +#define SCE_ASN1_COMMENT 1 +#define SCE_ASN1_IDENTIFIER 2 +#define SCE_ASN1_STRING 3 +#define SCE_ASN1_OID 4 +#define SCE_ASN1_SCALAR 5 +#define SCE_ASN1_KEYWORD 6 +#define SCE_ASN1_ATTRIBUTE 7 +#define SCE_ASN1_DESCRIPTOR 8 +#define SCE_ASN1_TYPE 9 +#define SCE_ASN1_OPERATOR 10 +#define SCE_VHDL_DEFAULT 0 +#define SCE_VHDL_COMMENT 1 +#define SCE_VHDL_COMMENTLINEBANG 2 +#define SCE_VHDL_NUMBER 3 +#define SCE_VHDL_STRING 4 +#define SCE_VHDL_OPERATOR 5 +#define SCE_VHDL_IDENTIFIER 6 +#define SCE_VHDL_STRINGEOL 7 +#define SCE_VHDL_KEYWORD 8 +#define SCE_VHDL_STDOPERATOR 9 +#define SCE_VHDL_ATTRIBUTE 10 +#define SCE_VHDL_STDFUNCTION 11 +#define SCE_VHDL_STDPACKAGE 12 +#define SCE_VHDL_STDTYPE 13 +#define SCE_VHDL_USERWORD 14 +#define SCE_CAML_DEFAULT 0 +#define SCE_CAML_IDENTIFIER 1 +#define SCE_CAML_TAGNAME 2 +#define SCE_CAML_KEYWORD 3 +#define SCE_CAML_KEYWORD2 4 +#define SCE_CAML_KEYWORD3 5 +#define SCE_CAML_LINENUM 6 +#define SCE_CAML_OPERATOR 7 +#define SCE_CAML_NUMBER 8 +#define SCE_CAML_CHAR 9 +#define SCE_CAML_WHITE 10 +#define SCE_CAML_STRING 11 +#define SCE_CAML_COMMENT 12 +#define SCE_CAML_COMMENT1 13 +#define SCE_CAML_COMMENT2 14 +#define SCE_CAML_COMMENT3 15 +#define SCE_HA_DEFAULT 0 +#define SCE_HA_IDENTIFIER 1 +#define SCE_HA_KEYWORD 2 +#define SCE_HA_NUMBER 3 +#define SCE_HA_STRING 4 +#define SCE_HA_CHARACTER 5 +#define SCE_HA_CLASS 6 +#define SCE_HA_MODULE 7 +#define SCE_HA_CAPITAL 8 +#define SCE_HA_DATA 9 +#define SCE_HA_IMPORT 10 +#define SCE_HA_OPERATOR 11 +#define SCE_HA_INSTANCE 12 +#define SCE_HA_COMMENTLINE 13 +#define SCE_HA_COMMENTBLOCK 14 +#define SCE_HA_COMMENTBLOCK2 15 +#define SCE_HA_COMMENTBLOCK3 16 +#define SCE_T3_DEFAULT 0 +#define SCE_T3_X_DEFAULT 1 +#define SCE_T3_PREPROCESSOR 2 +#define SCE_T3_BLOCK_COMMENT 3 +#define SCE_T3_LINE_COMMENT 4 +#define SCE_T3_OPERATOR 5 +#define SCE_T3_KEYWORD 6 +#define SCE_T3_NUMBER 7 +#define SCE_T3_IDENTIFIER 8 +#define SCE_T3_S_STRING 9 +#define SCE_T3_D_STRING 10 +#define SCE_T3_X_STRING 11 +#define SCE_T3_LIB_DIRECTIVE 12 +#define SCE_T3_MSG_PARAM 13 +#define SCE_T3_HTML_TAG 14 +#define SCE_T3_HTML_DEFAULT 15 +#define SCE_T3_HTML_STRING 16 +#define SCE_T3_USER1 17 +#define SCE_T3_USER2 18 +#define SCE_T3_USER3 19 +#define SCE_T3_BRACE 20 +#define SCE_REBOL_DEFAULT 0 +#define SCE_REBOL_COMMENTLINE 1 +#define SCE_REBOL_COMMENTBLOCK 2 +#define SCE_REBOL_PREFACE 3 +#define SCE_REBOL_OPERATOR 4 +#define SCE_REBOL_CHARACTER 5 +#define SCE_REBOL_QUOTEDSTRING 6 +#define SCE_REBOL_BRACEDSTRING 7 +#define SCE_REBOL_NUMBER 8 +#define SCE_REBOL_PAIR 9 +#define SCE_REBOL_TUPLE 10 +#define SCE_REBOL_BINARY 11 +#define SCE_REBOL_MONEY 12 +#define SCE_REBOL_ISSUE 13 +#define SCE_REBOL_TAG 14 +#define SCE_REBOL_FILE 15 +#define SCE_REBOL_EMAIL 16 +#define SCE_REBOL_URL 17 +#define SCE_REBOL_DATE 18 +#define SCE_REBOL_TIME 19 +#define SCE_REBOL_IDENTIFIER 20 +#define SCE_REBOL_WORD 21 +#define SCE_REBOL_WORD2 22 +#define SCE_REBOL_WORD3 23 +#define SCE_REBOL_WORD4 24 +#define SCE_REBOL_WORD5 25 +#define SCE_REBOL_WORD6 26 +#define SCE_REBOL_WORD7 27 +#define SCE_REBOL_WORD8 28 +#define SCE_SQL_DEFAULT 0 +#define SCE_SQL_COMMENT 1 +#define SCE_SQL_COMMENTLINE 2 +#define SCE_SQL_COMMENTDOC 3 +#define SCE_SQL_NUMBER 4 +#define SCE_SQL_WORD 5 +#define SCE_SQL_STRING 6 +#define SCE_SQL_CHARACTER 7 +#define SCE_SQL_SQLPLUS 8 +#define SCE_SQL_SQLPLUS_PROMPT 9 +#define SCE_SQL_OPERATOR 10 +#define SCE_SQL_IDENTIFIER 11 +#define SCE_SQL_SQLPLUS_COMMENT 13 +#define SCE_SQL_COMMENTLINEDOC 15 +#define SCE_SQL_WORD2 16 +#define SCE_SQL_COMMENTDOCKEYWORD 17 +#define SCE_SQL_COMMENTDOCKEYWORDERROR 18 +#define SCE_SQL_USER1 19 +#define SCE_SQL_USER2 20 +#define SCE_SQL_USER3 21 +#define SCE_SQL_USER4 22 +#define SCE_SQL_QUOTEDIDENTIFIER 23 +#define SCE_ST_DEFAULT 0 +#define SCE_ST_STRING 1 +#define SCE_ST_NUMBER 2 +#define SCE_ST_COMMENT 3 +#define SCE_ST_SYMBOL 4 +#define SCE_ST_BINARY 5 +#define SCE_ST_BOOL 6 +#define SCE_ST_SELF 7 +#define SCE_ST_SUPER 8 +#define SCE_ST_NIL 9 +#define SCE_ST_GLOBAL 10 +#define SCE_ST_RETURN 11 +#define SCE_ST_SPECIAL 12 +#define SCE_ST_KWSEND 13 +#define SCE_ST_ASSIGN 14 +#define SCE_ST_CHARACTER 15 +#define SCE_ST_SPEC_SEL 16 +#define SCE_FS_DEFAULT 0 +#define SCE_FS_COMMENT 1 +#define SCE_FS_COMMENTLINE 2 +#define SCE_FS_COMMENTDOC 3 +#define SCE_FS_COMMENTLINEDOC 4 +#define SCE_FS_COMMENTDOCKEYWORD 5 +#define SCE_FS_COMMENTDOCKEYWORDERROR 6 +#define SCE_FS_KEYWORD 7 +#define SCE_FS_KEYWORD2 8 +#define SCE_FS_KEYWORD3 9 +#define SCE_FS_KEYWORD4 10 +#define SCE_FS_NUMBER 11 +#define SCE_FS_STRING 12 +#define SCE_FS_PREPROCESSOR 13 +#define SCE_FS_OPERATOR 14 +#define SCE_FS_IDENTIFIER 15 +#define SCE_FS_DATE 16 +#define SCE_FS_STRINGEOL 17 +#define SCE_FS_CONSTANT 18 +#define SCE_FS_WORDOPERATOR 19 +#define SCE_FS_DISABLEDCODE 20 +#define SCE_FS_DEFAULT_C 21 +#define SCE_FS_COMMENTDOC_C 22 +#define SCE_FS_COMMENTLINEDOC_C 23 +#define SCE_FS_KEYWORD_C 24 +#define SCE_FS_KEYWORD2_C 25 +#define SCE_FS_NUMBER_C 26 +#define SCE_FS_STRING_C 27 +#define SCE_FS_PREPROCESSOR_C 28 +#define SCE_FS_OPERATOR_C 29 +#define SCE_FS_IDENTIFIER_C 30 +#define SCE_FS_STRINGEOL_C 31 +#define SCE_CSOUND_DEFAULT 0 +#define SCE_CSOUND_COMMENT 1 +#define SCE_CSOUND_NUMBER 2 +#define SCE_CSOUND_OPERATOR 3 +#define SCE_CSOUND_INSTR 4 +#define SCE_CSOUND_IDENTIFIER 5 +#define SCE_CSOUND_OPCODE 6 +#define SCE_CSOUND_HEADERSTMT 7 +#define SCE_CSOUND_USERKEYWORD 8 +#define SCE_CSOUND_COMMENTBLOCK 9 +#define SCE_CSOUND_PARAM 10 +#define SCE_CSOUND_ARATE_VAR 11 +#define SCE_CSOUND_KRATE_VAR 12 +#define SCE_CSOUND_IRATE_VAR 13 +#define SCE_CSOUND_GLOBAL_VAR 14 +#define SCE_CSOUND_STRINGEOL 15 +#define SCE_INNO_DEFAULT 0 +#define SCE_INNO_COMMENT 1 +#define SCE_INNO_KEYWORD 2 +#define SCE_INNO_PARAMETER 3 +#define SCE_INNO_SECTION 4 +#define SCE_INNO_PREPROC 5 +#define SCE_INNO_INLINE_EXPANSION 6 +#define SCE_INNO_COMMENT_PASCAL 7 +#define SCE_INNO_KEYWORD_PASCAL 8 +#define SCE_INNO_KEYWORD_USER 9 +#define SCE_INNO_STRING_DOUBLE 10 +#define SCE_INNO_STRING_SINGLE 11 +#define SCE_INNO_IDENTIFIER 12 +#define SCE_OPAL_SPACE 0 +#define SCE_OPAL_COMMENT_BLOCK 1 +#define SCE_OPAL_COMMENT_LINE 2 +#define SCE_OPAL_INTEGER 3 +#define SCE_OPAL_KEYWORD 4 +#define SCE_OPAL_SORT 5 +#define SCE_OPAL_STRING 6 +#define SCE_OPAL_PAR 7 +#define SCE_OPAL_BOOL_CONST 8 +#define SCE_OPAL_DEFAULT 32 +#define SCE_SPICE_DEFAULT 0 +#define SCE_SPICE_IDENTIFIER 1 +#define SCE_SPICE_KEYWORD 2 +#define SCE_SPICE_KEYWORD2 3 +#define SCE_SPICE_KEYWORD3 4 +#define SCE_SPICE_NUMBER 5 +#define SCE_SPICE_DELIMITER 6 +#define SCE_SPICE_VALUE 7 +#define SCE_SPICE_COMMENTLINE 8 +#define SCE_CMAKE_DEFAULT 0 +#define SCE_CMAKE_COMMENT 1 +#define SCE_CMAKE_STRINGDQ 2 +#define SCE_CMAKE_STRINGLQ 3 +#define SCE_CMAKE_STRINGRQ 4 +#define SCE_CMAKE_COMMANDS 5 +#define SCE_CMAKE_PARAMETERS 6 +#define SCE_CMAKE_VARIABLE 7 +#define SCE_CMAKE_USERDEFINED 8 +#define SCE_CMAKE_WHILEDEF 9 +#define SCE_CMAKE_FOREACHDEF 10 +#define SCE_CMAKE_IFDEFINEDEF 11 +#define SCE_CMAKE_MACRODEF 12 +#define SCE_CMAKE_STRINGVAR 13 +#define SCE_CMAKE_NUMBER 14 +#define SCE_GAP_DEFAULT 0 +#define SCE_GAP_IDENTIFIER 1 +#define SCE_GAP_KEYWORD 2 +#define SCE_GAP_KEYWORD2 3 +#define SCE_GAP_KEYWORD3 4 +#define SCE_GAP_KEYWORD4 5 +#define SCE_GAP_STRING 6 +#define SCE_GAP_CHAR 7 +#define SCE_GAP_OPERATOR 8 +#define SCE_GAP_COMMENT 9 +#define SCE_GAP_NUMBER 10 +#define SCE_GAP_STRINGEOL 11 +#define SCE_PLM_DEFAULT 0 +#define SCE_PLM_COMMENT 1 +#define SCE_PLM_STRING 2 +#define SCE_PLM_NUMBER 3 +#define SCE_PLM_IDENTIFIER 4 +#define SCE_PLM_OPERATOR 5 +#define SCE_PLM_CONTROL 6 +#define SCE_PLM_KEYWORD 7 +#define SCE_4GL_DEFAULT 0 +#define SCE_4GL_NUMBER 1 +#define SCE_4GL_WORD 2 +#define SCE_4GL_STRING 3 +#define SCE_4GL_CHARACTER 4 +#define SCE_4GL_PREPROCESSOR 5 +#define SCE_4GL_OPERATOR 6 +#define SCE_4GL_IDENTIFIER 7 +#define SCE_4GL_BLOCK 8 +#define SCE_4GL_END 9 +#define SCE_4GL_COMMENT1 10 +#define SCE_4GL_COMMENT2 11 +#define SCE_4GL_COMMENT3 12 +#define SCE_4GL_COMMENT4 13 +#define SCE_4GL_COMMENT5 14 +#define SCE_4GL_COMMENT6 15 +#define SCE_4GL_DEFAULT_ 16 +#define SCE_4GL_NUMBER_ 17 +#define SCE_4GL_WORD_ 18 +#define SCE_4GL_STRING_ 19 +#define SCE_4GL_CHARACTER_ 20 +#define SCE_4GL_PREPROCESSOR_ 21 +#define SCE_4GL_OPERATOR_ 22 +#define SCE_4GL_IDENTIFIER_ 23 +#define SCE_4GL_BLOCK_ 24 +#define SCE_4GL_END_ 25 +#define SCE_4GL_COMMENT1_ 26 +#define SCE_4GL_COMMENT2_ 27 +#define SCE_4GL_COMMENT3_ 28 +#define SCE_4GL_COMMENT4_ 29 +#define SCE_4GL_COMMENT5_ 30 +#define SCE_4GL_COMMENT6_ 31 +#define SCE_ABAQUS_DEFAULT 0 +#define SCE_ABAQUS_COMMENT 1 +#define SCE_ABAQUS_COMMENTBLOCK 2 +#define SCE_ABAQUS_NUMBER 3 +#define SCE_ABAQUS_STRING 4 +#define SCE_ABAQUS_OPERATOR 5 +#define SCE_ABAQUS_WORD 6 +#define SCE_ABAQUS_PROCESSOR 7 +#define SCE_ABAQUS_COMMAND 8 +#define SCE_ABAQUS_SLASHCOMMAND 9 +#define SCE_ABAQUS_STARCOMMAND 10 +#define SCE_ABAQUS_ARGUMENT 11 +#define SCE_ABAQUS_FUNCTION 12 +#define SCE_ASY_DEFAULT 0 +#define SCE_ASY_COMMENT 1 +#define SCE_ASY_COMMENTLINE 2 +#define SCE_ASY_NUMBER 3 +#define SCE_ASY_WORD 4 +#define SCE_ASY_STRING 5 +#define SCE_ASY_CHARACTER 6 +#define SCE_ASY_OPERATOR 7 +#define SCE_ASY_IDENTIFIER 8 +#define SCE_ASY_STRINGEOL 9 +#define SCE_ASY_COMMENTLINEDOC 10 +#define SCE_ASY_WORD2 11 +#define SCE_R_DEFAULT 0 +#define SCE_R_COMMENT 1 +#define SCE_R_KWORD 2 +#define SCE_R_BASEKWORD 3 +#define SCE_R_OTHERKWORD 4 +#define SCE_R_NUMBER 5 +#define SCE_R_STRING 6 +#define SCE_R_STRING2 7 +#define SCE_R_OPERATOR 8 +#define SCE_R_IDENTIFIER 9 +#define SCE_R_INFIX 10 +#define SCE_R_INFIXEOL 11 +#define SCE_MAGIK_DEFAULT 0 +#define SCE_MAGIK_COMMENT 1 +#define SCE_MAGIK_HYPER_COMMENT 16 +#define SCE_MAGIK_STRING 2 +#define SCE_MAGIK_CHARACTER 3 +#define SCE_MAGIK_NUMBER 4 +#define SCE_MAGIK_IDENTIFIER 5 +#define SCE_MAGIK_OPERATOR 6 +#define SCE_MAGIK_FLOW 7 +#define SCE_MAGIK_CONTAINER 8 +#define SCE_MAGIK_BRACKET_BLOCK 9 +#define SCE_MAGIK_BRACE_BLOCK 10 +#define SCE_MAGIK_SQBRACKET_BLOCK 11 +#define SCE_MAGIK_UNKNOWN_KEYWORD 12 +#define SCE_MAGIK_KEYWORD 13 +#define SCE_MAGIK_PRAGMA 14 +#define SCE_MAGIK_SYMBOL 15 +#define SCE_POWERSHELL_DEFAULT 0 +#define SCE_POWERSHELL_COMMENT 1 +#define SCE_POWERSHELL_STRING 2 +#define SCE_POWERSHELL_CHARACTER 3 +#define SCE_POWERSHELL_NUMBER 4 +#define SCE_POWERSHELL_VARIABLE 5 +#define SCE_POWERSHELL_OPERATOR 6 +#define SCE_POWERSHELL_IDENTIFIER 7 +#define SCE_POWERSHELL_KEYWORD 8 +#define SCE_POWERSHELL_CMDLET 9 +#define SCE_POWERSHELL_ALIAS 10 +#define SCE_MYSQL_DEFAULT 0 +#define SCE_MYSQL_COMMENT 1 +#define SCE_MYSQL_COMMENTLINE 2 +#define SCE_MYSQL_VARIABLE 3 +#define SCE_MYSQL_SYSTEMVARIABLE 4 +#define SCE_MYSQL_KNOWNSYSTEMVARIABLE 5 +#define SCE_MYSQL_NUMBER 6 +#define SCE_MYSQL_MAJORKEYWORD 7 +#define SCE_MYSQL_KEYWORD 8 +#define SCE_MYSQL_DATABASEOBJECT 9 +#define SCE_MYSQL_PROCEDUREKEYWORD 10 +#define SCE_MYSQL_STRING 11 +#define SCE_MYSQL_SQSTRING 12 +#define SCE_MYSQL_DQSTRING 13 +#define SCE_MYSQL_OPERATOR 14 +#define SCE_MYSQL_FUNCTION 15 +#define SCE_MYSQL_IDENTIFIER 16 +#define SCE_MYSQL_QUOTEDIDENTIFIER 17 +#define SCE_MYSQL_USER1 18 +#define SCE_MYSQL_USER2 19 +#define SCE_MYSQL_USER3 20 +#define SCE_MYSQL_HIDDENCOMMAND 21 +#define SCE_PO_DEFAULT 0 +#define SCE_PO_COMMENT 1 +#define SCE_PO_MSGID 2 +#define SCE_PO_MSGID_TEXT 3 +#define SCE_PO_MSGSTR 4 +#define SCE_PO_MSGSTR_TEXT 5 +#define SCE_PO_MSGCTXT 6 +#define SCE_PO_MSGCTXT_TEXT 7 +#define SCE_PO_FUZZY 8 +#define SCE_PAS_DEFAULT 0 +#define SCE_PAS_IDENTIFIER 1 +#define SCE_PAS_COMMENT 2 +#define SCE_PAS_COMMENT2 3 +#define SCE_PAS_COMMENTLINE 4 +#define SCE_PAS_PREPROCESSOR 5 +#define SCE_PAS_PREPROCESSOR2 6 +#define SCE_PAS_NUMBER 7 +#define SCE_PAS_HEXNUMBER 8 +#define SCE_PAS_WORD 9 +#define SCE_PAS_STRING 10 +#define SCE_PAS_STRINGEOL 11 +#define SCE_PAS_CHARACTER 12 +#define SCE_PAS_OPERATOR 13 +#define SCE_PAS_ASM 14 +#define SCE_SORCUS_DEFAULT 0 +#define SCE_SORCUS_COMMAND 1 +#define SCE_SORCUS_PARAMETER 2 +#define SCE_SORCUS_COMMENTLINE 3 +#define SCE_SORCUS_STRING 4 +#define SCE_SORCUS_STRINGEOL 5 +#define SCE_SORCUS_IDENTIFIER 6 +#define SCE_SORCUS_OPERATOR 7 +#define SCE_SORCUS_NUMBER 8 +#define SCE_SORCUS_CONSTANT 9 +#define SCE_POWERPRO_DEFAULT 0 +#define SCE_POWERPRO_COMMENTBLOCK 1 +#define SCE_POWERPRO_COMMENTLINE 2 +#define SCE_POWERPRO_NUMBER 3 +#define SCE_POWERPRO_WORD 4 +#define SCE_POWERPRO_WORD2 5 +#define SCE_POWERPRO_WORD3 6 +#define SCE_POWERPRO_WORD4 7 +#define SCE_POWERPRO_DOUBLEQUOTEDSTRING 8 +#define SCE_POWERPRO_SINGLEQUOTEDSTRING 9 +#define SCE_POWERPRO_LINECONTINUE 10 +#define SCE_POWERPRO_OPERATOR 11 +#define SCE_POWERPRO_IDENTIFIER 12 +#define SCE_POWERPRO_STRINGEOL 13 +#define SCE_POWERPRO_VERBATIM 14 +#define SCE_POWERPRO_ALTQUOTE 15 +#define SCE_POWERPRO_FUNCTION 16 +#define SCE_SML_DEFAULT 0 +#define SCE_SML_IDENTIFIER 1 +#define SCE_SML_TAGNAME 2 +#define SCE_SML_KEYWORD 3 +#define SCE_SML_KEYWORD2 4 +#define SCE_SML_KEYWORD3 5 +#define SCE_SML_LINENUM 6 +#define SCE_SML_OPERATOR 7 +#define SCE_SML_NUMBER 8 +#define SCE_SML_CHAR 9 +#define SCE_SML_STRING 11 +#define SCE_SML_COMMENT 12 +#define SCE_SML_COMMENT1 13 +#define SCE_SML_COMMENT2 14 +#define SCE_SML_COMMENT3 15 +#define SCE_MARKDOWN_DEFAULT 0 +#define SCE_MARKDOWN_LINE_BEGIN 1 +#define SCE_MARKDOWN_STRONG1 2 +#define SCE_MARKDOWN_STRONG2 3 +#define SCE_MARKDOWN_EM1 4 +#define SCE_MARKDOWN_EM2 5 +#define SCE_MARKDOWN_HEADER1 6 +#define SCE_MARKDOWN_HEADER2 7 +#define SCE_MARKDOWN_HEADER3 8 +#define SCE_MARKDOWN_HEADER4 9 +#define SCE_MARKDOWN_HEADER5 10 +#define SCE_MARKDOWN_HEADER6 11 +#define SCE_MARKDOWN_PRECHAR 12 +#define SCE_MARKDOWN_ULIST_ITEM 13 +#define SCE_MARKDOWN_OLIST_ITEM 14 +#define SCE_MARKDOWN_BLOCKQUOTE 15 +#define SCE_MARKDOWN_STRIKEOUT 16 +#define SCE_MARKDOWN_HRULE 17 +#define SCE_MARKDOWN_LINK 18 +#define SCE_MARKDOWN_CODE 19 +#define SCE_MARKDOWN_CODE2 20 +#define SCE_MARKDOWN_CODEBK 21 +/* --Autogenerated -- end of section automatically generated from Scintilla.iface */ + +#endif diff --git a/sdk/wxscintilla/src/scintilla/include/Scintilla.h b/sdk/wxscintilla/src/scintilla/include/Scintilla.h new file mode 100644 index 0000000..c5e6a1e --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/Scintilla.h @@ -0,0 +1,974 @@ +/* Scintilla source code edit control */ +/** @file Scintilla.h + ** Interface to the edit control. + **/ +/* Copyright 1998-2003 by Neil Hodgson + * The License.txt file describes the conditions under which this software may be distributed. */ + +/* Most of this file is automatically generated from the Scintilla.iface interface definition + * file which contains any comments about the definitions. HFacer.py does the generation. */ + +#ifndef SCINTILLA_H +#define SCINTILLA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_WIN32) +/* Return false on failure: */ +int Scintilla_RegisterClasses(void *hInstance); +int Scintilla_ReleaseResources(); +#endif +int Scintilla_LinkLexers(); + +#ifdef __cplusplus +} +#endif + +/* Here should be placed typedefs for uptr_t, an unsigned integer type large enough to + * hold a pointer and sptr_t, a signed integer large enough to hold a pointer. + * May need to be changed for 64 bit platforms. */ +#if defined(_WIN32) +#include +#endif +#ifdef MAXULONG_PTR +typedef ULONG_PTR uptr_t; +typedef LONG_PTR sptr_t; +#else +typedef unsigned long uptr_t; +typedef long sptr_t; +#endif + +typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam); + +/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */ +#define INVALID_POSITION -1 +#define SCI_START 2000 +#define SCI_OPTIONAL_START 3000 +#define SCI_LEXER_START 4000 +#define SCI_ADDTEXT 2001 +#define SCI_ADDSTYLEDTEXT 2002 +#define SCI_INSERTTEXT 2003 +#define SCI_CLEARALL 2004 +#define SCI_CLEARDOCUMENTSTYLE 2005 +#define SCI_GETLENGTH 2006 +#define SCI_GETCHARAT 2007 +#define SCI_GETCURRENTPOS 2008 +#define SCI_GETANCHOR 2009 +#define SCI_GETSTYLEAT 2010 +#define SCI_REDO 2011 +#define SCI_SETUNDOCOLLECTION 2012 +#define SCI_SELECTALL 2013 +#define SCI_SETSAVEPOINT 2014 +#define SCI_GETSTYLEDTEXT 2015 +#define SCI_CANREDO 2016 +#define SCI_MARKERLINEFROMHANDLE 2017 +#define SCI_MARKERDELETEHANDLE 2018 +#define SCI_GETUNDOCOLLECTION 2019 +#define SCWS_INVISIBLE 0 +#define SCWS_VISIBLEALWAYS 1 +#define SCWS_VISIBLEAFTERINDENT 2 +#define SCI_GETVIEWWS 2020 +#define SCI_SETVIEWWS 2021 +#define SCI_POSITIONFROMPOINT 2022 +#define SCI_POSITIONFROMPOINTCLOSE 2023 +#define SCI_GOTOLINE 2024 +#define SCI_GOTOPOS 2025 +#define SCI_SETANCHOR 2026 +#define SCI_GETCURLINE 2027 +#define SCI_GETENDSTYLED 2028 +#define SC_EOL_CRLF 0 +#define SC_EOL_CR 1 +#define SC_EOL_LF 2 +#define SCI_CONVERTEOLS 2029 +#define SCI_GETEOLMODE 2030 +#define SCI_SETEOLMODE 2031 +#define SCI_STARTSTYLING 2032 +#define SCI_SETSTYLING 2033 +#define SCI_GETBUFFEREDDRAW 2034 +#define SCI_SETBUFFEREDDRAW 2035 +#define SCI_SETTABWIDTH 2036 +#define SCI_GETTABWIDTH 2121 +#define SC_CP_UTF8 65001 +#define SC_CP_DBCS 1 +#define SCI_SETCODEPAGE 2037 +#define SCI_SETUSEPALETTE 2039 +#define MARKER_MAX 31 +#define SC_MARK_CIRCLE 0 +#define SC_MARK_ROUNDRECT 1 +#define SC_MARK_ARROW 2 +#define SC_MARK_SMALLRECT 3 +#define SC_MARK_SHORTARROW 4 +#define SC_MARK_EMPTY 5 +#define SC_MARK_ARROWDOWN 6 +#define SC_MARK_MINUS 7 +#define SC_MARK_PLUS 8 +#define SC_MARK_VLINE 9 +#define SC_MARK_LCORNER 10 +#define SC_MARK_TCORNER 11 +#define SC_MARK_BOXPLUS 12 +#define SC_MARK_BOXPLUSCONNECTED 13 +#define SC_MARK_BOXMINUS 14 +#define SC_MARK_BOXMINUSCONNECTED 15 +#define SC_MARK_LCORNERCURVE 16 +#define SC_MARK_TCORNERCURVE 17 +#define SC_MARK_CIRCLEPLUS 18 +#define SC_MARK_CIRCLEPLUSCONNECTED 19 +#define SC_MARK_CIRCLEMINUS 20 +#define SC_MARK_CIRCLEMINUSCONNECTED 21 +#define SC_MARK_BACKGROUND 22 +#define SC_MARK_DOTDOTDOT 23 +#define SC_MARK_ARROWS 24 +#define SC_MARK_PIXMAP 25 +#define SC_MARK_FULLRECT 26 +#define SC_MARK_LEFTRECT 27 +#define SC_MARK_AVAILABLE 28 +#define SC_MARK_UNDERLINE 29 +#define SC_MARK_ARROW_IN_BOX 100 +#define SC_MARK_ARROWDOWN_IN_BOX 101 +#define SC_MARK_FULLRECT_TAIL 102 +#define SC_MARK_PLUS_IN_BOX 103 +#define SC_MARK_MINUS_IN_BOX 104 + +#define SC_MARK_CHARACTER 10000 +#define SC_MARKNUM_FOLDEREND 25 +#define SC_MARKNUM_FOLDEROPENMID 26 +#define SC_MARKNUM_FOLDERMIDTAIL 27 +#define SC_MARKNUM_FOLDERTAIL 28 +#define SC_MARKNUM_FOLDERSUB 29 +#define SC_MARKNUM_FOLDER 30 +#define SC_MARKNUM_FOLDEROPEN 31 +#define SC_MASK_FOLDERS 0xFE000000 +#define SCI_MARKERDEFINE 2040 +#define SCI_MARKERSETFORE 2041 +#define SCI_MARKERSETBACK 2042 +#define SCI_MARKERADD 2043 +#define SCI_MARKERDELETE 2044 +#define SCI_MARKERDELETEALL 2045 +#define SCI_MARKERGET 2046 +#define SCI_MARKERNEXT 2047 +#define SCI_MARKERPREVIOUS 2048 +#define SCI_MARKERDEFINEPIXMAP 2049 +#define SCI_MARKERADDSET 2466 +#define SCI_MARKERSETALPHA 2476 +#define SC_MARGIN_SYMBOL 0 +#define SC_MARGIN_NUMBER 1 +#define SC_MARGIN_BACK 2 +#define SC_MARGIN_FORE 3 +#define SC_MARGIN_TEXT 4 +#define SC_MARGIN_RTEXT 5 +#define SCI_SETMARGINTYPEN 2240 +#define SCI_GETMARGINTYPEN 2241 +#define SCI_SETMARGINWIDTHN 2242 +#define SCI_GETMARGINWIDTHN 2243 +#define SCI_SETMARGINMASKN 2244 +#define SCI_GETMARGINMASKN 2245 +#define SCI_SETMARGINSENSITIVEN 2246 +#define SCI_GETMARGINSENSITIVEN 2247 +#define STYLE_DEFAULT 32 +#define STYLE_LINENUMBER 33 +#define STYLE_BRACELIGHT 34 +#define STYLE_BRACEBAD 35 +#define STYLE_CONTROLCHAR 36 +#define STYLE_INDENTGUIDE 37 +#define STYLE_CALLTIP 38 +#define STYLE_LASTPREDEFINED 39 +#define STYLE_MAX 255 +#define SC_CHARSET_ANSI 0 +#define SC_CHARSET_DEFAULT 1 +#define SC_CHARSET_BALTIC 186 +#define SC_CHARSET_CHINESEBIG5 136 +#define SC_CHARSET_EASTEUROPE 238 +#define SC_CHARSET_GB2312 134 +#define SC_CHARSET_GREEK 161 +#define SC_CHARSET_HANGUL 129 +#define SC_CHARSET_MAC 77 +#define SC_CHARSET_OEM 255 +#define SC_CHARSET_RUSSIAN 204 +#define SC_CHARSET_CYRILLIC 1251 +#define SC_CHARSET_SHIFTJIS 128 +#define SC_CHARSET_SYMBOL 2 +#define SC_CHARSET_TURKISH 162 +#define SC_CHARSET_JOHAB 130 +#define SC_CHARSET_HEBREW 177 +#define SC_CHARSET_ARABIC 178 +#define SC_CHARSET_VIETNAMESE 163 +#define SC_CHARSET_THAI 222 +#define SC_CHARSET_8859_15 1000 +#define SCI_STYLECLEARALL 2050 +#define SCI_STYLESETFORE 2051 +#define SCI_STYLESETBACK 2052 +#define SCI_STYLESETBOLD 2053 +#define SCI_STYLESETITALIC 2054 +#define SCI_STYLESETSIZE 2055 +#define SCI_STYLESETFONT 2056 +#define SCI_STYLESETEOLFILLED 2057 +#define SCI_STYLERESETDEFAULT 2058 +#define SCI_STYLESETUNDERLINE 2059 +#define SC_CASE_MIXED 0 +#define SC_CASE_UPPER 1 +#define SC_CASE_LOWER 2 +#define SCI_STYLEGETFORE 2481 +#define SCI_STYLEGETBACK 2482 +#define SCI_STYLEGETBOLD 2483 +#define SCI_STYLEGETITALIC 2484 +#define SCI_STYLEGETSIZE 2485 +#define SCI_STYLEGETFONT 2486 +#define SCI_STYLEGETEOLFILLED 2487 +#define SCI_STYLEGETUNDERLINE 2488 +#define SCI_STYLEGETCASE 2489 +#define SCI_STYLEGETCHARACTERSET 2490 +#define SCI_STYLEGETVISIBLE 2491 +#define SCI_STYLEGETCHANGEABLE 2492 +#define SCI_STYLEGETHOTSPOT 2493 +#define SCI_STYLESETCASE 2060 +#define SCI_STYLESETCHARACTERSET 2066 +#define SCI_STYLESETHOTSPOT 2409 +#define SCI_SETSELFORE 2067 +#define SCI_SETSELBACK 2068 +#define SCI_GETSELALPHA 2477 +#define SCI_SETSELALPHA 2478 +#define SCI_GETSELEOLFILLED 2479 +#define SCI_SETSELEOLFILLED 2480 +#define SCI_SETCARETFORE 2069 +#define SCI_ASSIGNCMDKEY 2070 +#define SCI_CLEARCMDKEY 2071 +#define SCI_CLEARALLCMDKEYS 2072 +#define SCI_SETSTYLINGEX 2073 +#define SCI_STYLESETVISIBLE 2074 +#define SCI_GETCARETPERIOD 2075 +#define SCI_SETCARETPERIOD 2076 +#define SCI_SETWORDCHARS 2077 +#define SCI_BEGINUNDOACTION 2078 +#define SCI_ENDUNDOACTION 2079 +#define INDIC_PLAIN 0 +#define INDIC_SQUIGGLE 1 +#define INDIC_TT 2 +#define INDIC_DIAGONAL 3 +#define INDIC_STRIKE 4 +#define INDIC_HIDDEN 5 +#define INDIC_BOX 6 +#define INDIC_ROUNDBOX 7 +#define INDIC_MAX 31 +#define INDIC_CONTAINER 8 +#define INDIC0_MASK 0x20 +#define INDIC1_MASK 0x40 +#define INDIC2_MASK 0x80 +#define INDICS_MASK 0xE0 +#define SCI_INDICSETSTYLE 2080 +#define SCI_INDICGETSTYLE 2081 +#define SCI_INDICSETFORE 2082 +#define SCI_INDICGETFORE 2083 +#define SCI_INDICSETUNDER 2510 +#define SCI_INDICGETUNDER 2511 +#define SCI_SETWHITESPACEFORE 2084 +#define SCI_SETWHITESPACEBACK 2085 +#define SCI_SETWHITESPACESIZE 2086 +#define SCI_GETWHITESPACESIZE 2087 +#define SCI_SETSTYLEBITS 2090 +#define SCI_GETSTYLEBITS 2091 +#define SCI_SETLINESTATE 2092 +#define SCI_GETLINESTATE 2093 +#define SCI_GETMAXLINESTATE 2094 +#define SCI_GETCARETLINEVISIBLE 2095 +#define SCI_SETCARETLINEVISIBLE 2096 +#define SCI_GETCARETLINEBACK 2097 +#define SCI_SETCARETLINEBACK 2098 +#define SCI_STYLESETCHANGEABLE 2099 +#define SCI_AUTOCSHOW 2100 +#define SCI_AUTOCCANCEL 2101 +#define SCI_AUTOCACTIVE 2102 +#define SCI_AUTOCPOSSTART 2103 +#define SCI_AUTOCCOMPLETE 2104 +#define SCI_AUTOCSTOPS 2105 +#define SCI_AUTOCSETSEPARATOR 2106 +#define SCI_AUTOCGETSEPARATOR 2107 +#define SCI_AUTOCSELECT 2108 +#define SCI_AUTOCSETCANCELATSTART 2110 +#define SCI_AUTOCGETCANCELATSTART 2111 +#define SCI_AUTOCSETFILLUPS 2112 +#define SCI_AUTOCSETCHOOSESINGLE 2113 +#define SCI_AUTOCGETCHOOSESINGLE 2114 +#define SCI_AUTOCSETIGNORECASE 2115 +#define SCI_AUTOCGETIGNORECASE 2116 +#define SCI_USERLISTSHOW 2117 +#define SCI_AUTOCSETAUTOHIDE 2118 +#define SCI_AUTOCGETAUTOHIDE 2119 +#define SCI_AUTOCSETDROPRESTOFWORD 2270 +#define SCI_AUTOCGETDROPRESTOFWORD 2271 +#define SCI_REGISTERIMAGE 2405 +#define SCI_CLEARREGISTEREDIMAGES 2408 +#define SCI_AUTOCGETTYPESEPARATOR 2285 +#define SCI_AUTOCSETTYPESEPARATOR 2286 +#define SCI_AUTOCSETMAXWIDTH 2208 +#define SCI_AUTOCGETMAXWIDTH 2209 +#define SCI_AUTOCSETMAXHEIGHT 2210 +#define SCI_AUTOCGETMAXHEIGHT 2211 +#define SCI_SETINDENT 2122 +#define SCI_GETINDENT 2123 +#define SCI_SETUSETABS 2124 +#define SCI_GETUSETABS 2125 +#define SCI_SETLINEINDENTATION 2126 +#define SCI_GETLINEINDENTATION 2127 +#define SCI_GETLINEINDENTPOSITION 2128 +#define SCI_GETCOLUMN 2129 +#define SCI_SETHSCROLLBAR 2130 +#define SCI_GETHSCROLLBAR 2131 +#define SC_IV_NONE 0 +#define SC_IV_REAL 1 +#define SC_IV_LOOKFORWARD 2 +#define SC_IV_LOOKBOTH 3 +#define SCI_SETINDENTATIONGUIDES 2132 +#define SCI_GETINDENTATIONGUIDES 2133 +#define SCI_SETHIGHLIGHTGUIDE 2134 +#define SCI_GETHIGHLIGHTGUIDE 2135 +#define SCI_GETLINEENDPOSITION 2136 +#define SCI_GETCODEPAGE 2137 +#define SCI_GETCARETFORE 2138 +#define SCI_GETUSEPALETTE 2139 +#define SCI_GETREADONLY 2140 +#define SCI_SETCURRENTPOS 2141 +#define SCI_SETSELECTIONSTART 2142 +#define SCI_GETSELECTIONSTART 2143 +#define SCI_SETSELECTIONEND 2144 +#define SCI_GETSELECTIONEND 2145 +#define SCI_SETPRINTMAGNIFICATION 2146 +#define SCI_GETPRINTMAGNIFICATION 2147 +#define SC_PRINT_NORMAL 0 +#define SC_PRINT_INVERTLIGHT 1 +#define SC_PRINT_BLACKONWHITE 2 +#define SC_PRINT_COLOURONWHITE 3 +#define SC_PRINT_COLOURONWHITEDEFAULTBG 4 +#define SCI_SETPRINTCOLOURMODE 2148 +#define SCI_GETPRINTCOLOURMODE 2149 +#define SCFIND_WHOLEWORD 2 +#define SCFIND_MATCHCASE 4 +#define SCFIND_WORDSTART 0x00100000 +#define SCFIND_REGEXP 0x00200000 +#define SCFIND_POSIX 0x00400000 +#define SCI_FINDTEXT 2150 +#define SCI_FORMATRANGE 2151 +#define SCI_GETFIRSTVISIBLELINE 2152 +#define SCI_GETLINE 2153 +#define SCI_GETLINECOUNT 2154 +#define SCI_SETMARGINLEFT 2155 +#define SCI_GETMARGINLEFT 2156 +#define SCI_SETMARGINRIGHT 2157 +#define SCI_GETMARGINRIGHT 2158 +#define SCI_GETMODIFY 2159 +#define SCI_SETSEL 2160 +#define SCI_GETSELTEXT 2161 +#define SCI_GETTEXTRANGE 2162 +#define SCI_HIDESELECTION 2163 +#define SCI_POINTXFROMPOSITION 2164 +#define SCI_POINTYFROMPOSITION 2165 +#define SCI_LINEFROMPOSITION 2166 +#define SCI_POSITIONFROMLINE 2167 +#define SCI_LINESCROLL 2168 +#define SCI_SCROLLCARET 2169 +#define SCI_REPLACESEL 2170 +#define SCI_SETREADONLY 2171 +#define SCI_NULL 2172 +#define SCI_CANPASTE 2173 +#define SCI_CANUNDO 2174 +#define SCI_EMPTYUNDOBUFFER 2175 +#define SCI_UNDO 2176 +#define SCI_CUT 2177 +#define SCI_COPY 2178 +#define SCI_PASTE 2179 +#define SCI_CLEAR 2180 +#define SCI_SETTEXT 2181 +#define SCI_GETTEXT 2182 +#define SCI_GETTEXTLENGTH 2183 +#define SCI_GETDIRECTFUNCTION 2184 +#define SCI_GETDIRECTPOINTER 2185 +#define SCI_SETOVERTYPE 2186 +#define SCI_GETOVERTYPE 2187 +#define SCI_SETCARETWIDTH 2188 +#define SCI_GETCARETWIDTH 2189 +#define SCI_SETTARGETSTART 2190 +#define SCI_GETTARGETSTART 2191 +#define SCI_SETTARGETEND 2192 +#define SCI_GETTARGETEND 2193 +#define SCI_REPLACETARGET 2194 +#define SCI_REPLACETARGETRE 2195 +#define SCI_SEARCHINTARGET 2197 +#define SCI_SETSEARCHFLAGS 2198 +#define SCI_GETSEARCHFLAGS 2199 +#define SCI_CALLTIPSHOW 2200 +#define SCI_CALLTIPCANCEL 2201 +#define SCI_CALLTIPACTIVE 2202 +#define SCI_CALLTIPPOSSTART 2203 +#define SCI_CALLTIPSETHLT 2204 +#define SCI_CALLTIPSETBACK 2205 +#define SCI_CALLTIPSETFORE 2206 +#define SCI_CALLTIPSETFOREHLT 2207 +#define SCI_CALLTIPUSESTYLE 2212 +#define SCI_VISIBLEFROMDOCLINE 2220 +#define SCI_DOCLINEFROMVISIBLE 2221 +#define SCI_WRAPCOUNT 2235 +//ERAN IFRAH +#define SCI_CALLTIPSHOWEXT 22250 +// END +#define SC_FOLDLEVELBASE 0x400 +#define SC_FOLDLEVELWHITEFLAG 0x1000 +#define SC_FOLDLEVELHEADERFLAG 0x2000 +#define SC_FOLDLEVELNUMBERMASK 0x0FFF +#define SCI_SETFOLDLEVEL 2222 +#define SCI_GETFOLDLEVEL 2223 +#define SCI_GETLASTCHILD 2224 +#define SCI_GETFOLDPARENT 2225 +#define SCI_SHOWLINES 2226 +#define SCI_HIDELINES 2227 +#define SCI_GETLINEVISIBLE 2228 +#define SCI_SETFOLDEXPANDED 2229 +#define SCI_GETFOLDEXPANDED 2230 +#define SCI_TOGGLEFOLD 2231 +#define SCI_ENSUREVISIBLE 2232 +#define SC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002 +#define SC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004 +#define SC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008 +#define SC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010 +#define SC_FOLDFLAG_LEVELNUMBERS 0x0040 +#define SCI_SETFOLDFLAGS 2233 +#define SCI_ENSUREVISIBLEENFORCEPOLICY 2234 +#define SCI_SETTABINDENTS 2260 +#define SCI_GETTABINDENTS 2261 +#define SCI_SETBACKSPACEUNINDENTS 2262 +#define SCI_GETBACKSPACEUNINDENTS 2263 +#define SC_TIME_FOREVER 10000000 +#define SCI_SETMOUSEDWELLTIME 2264 +#define SCI_GETMOUSEDWELLTIME 2265 +#define SCI_WORDSTARTPOSITION 2266 +#define SCI_WORDENDPOSITION 2267 +#define SC_WRAP_NONE 0 +#define SC_WRAP_WORD 1 +#define SC_WRAP_CHAR 2 +#define SCI_SETWRAPMODE 2268 +#define SCI_GETWRAPMODE 2269 +#define SC_WRAPVISUALFLAG_NONE 0x0000 +#define SC_WRAPVISUALFLAG_END 0x0001 +#define SC_WRAPVISUALFLAG_START 0x0002 +#define SCI_SETWRAPVISUALFLAGS 2460 +#define SCI_GETWRAPVISUALFLAGS 2461 +#define SC_WRAPVISUALFLAGLOC_DEFAULT 0x0000 +#define SC_WRAPVISUALFLAGLOC_END_BY_TEXT 0x0001 +#define SC_WRAPVISUALFLAGLOC_START_BY_TEXT 0x0002 +#define SCI_SETWRAPVISUALFLAGSLOCATION 2462 +#define SCI_GETWRAPVISUALFLAGSLOCATION 2463 +#define SCI_SETWRAPSTARTINDENT 2464 +#define SCI_GETWRAPSTARTINDENT 2465 +#define SC_WRAPINDENT_FIXED 0 +#define SC_WRAPINDENT_SAME 1 +#define SC_WRAPINDENT_INDENT 2 +#define SCI_SETWRAPINDENTMODE 2472 +#define SCI_GETWRAPINDENTMODE 2473 +#define SC_CACHE_NONE 0 +#define SC_CACHE_CARET 1 +#define SC_CACHE_PAGE 2 +#define SC_CACHE_DOCUMENT 3 +#define SCI_SETLAYOUTCACHE 2272 +#define SCI_GETLAYOUTCACHE 2273 +#define SCI_SETSCROLLWIDTH 2274 +#define SCI_GETSCROLLWIDTH 2275 +#define SCI_SETSCROLLWIDTHTRACKING 2516 +#define SCI_GETSCROLLWIDTHTRACKING 2517 +#define SCI_TEXTWIDTH 2276 +#define SCI_SETENDATLASTLINE 2277 +#define SCI_GETENDATLASTLINE 2278 +#define SCI_TEXTHEIGHT 2279 +#define SCI_SETVSCROLLBAR 2280 +#define SCI_GETVSCROLLBAR 2281 +#define SCI_APPENDTEXT 2282 +#define SCI_GETTWOPHASEDRAW 2283 +#define SCI_SETTWOPHASEDRAW 2284 +#define SC_EFF_QUALITY_MASK 0xF +#define SC_EFF_QUALITY_DEFAULT 0 +#define SC_EFF_QUALITY_NON_ANTIALIASED 1 +#define SC_EFF_QUALITY_ANTIALIASED 2 +#define SC_EFF_QUALITY_LCD_OPTIMIZED 3 +#define SCI_SETFONTQUALITY 2611 +#define SCI_GETFONTQUALITY 2612 +#define SCI_SETFIRSTVISIBLELINE 2613 +#define SC_MULTIPASTE_ONCE 0 +#define SC_MULTIPASTE_EACH 1 +#define SCI_SETMULTIPASTE 2614 +#define SCI_GETMULTIPASTE 2615 +#define SCI_GETTAG 2616 +#define SCI_TARGETFROMSELECTION 2287 +#define SCI_LINESJOIN 2288 +#define SCI_LINESSPLIT 2289 +#define SCI_SETFOLDMARGINCOLOUR 2290 +#define SCI_SETFOLDMARGINHICOLOUR 2291 +#define SCI_LINEDOWN 2300 +#define SCI_LINEDOWNEXTEND 2301 +#define SCI_LINEUP 2302 +#define SCI_LINEUPEXTEND 2303 +#define SCI_CHARLEFT 2304 +#define SCI_CHARLEFTEXTEND 2305 +#define SCI_CHARRIGHT 2306 +#define SCI_CHARRIGHTEXTEND 2307 +#define SCI_WORDLEFT 2308 +#define SCI_WORDLEFTEXTEND 2309 +#define SCI_WORDRIGHT 2310 +#define SCI_WORDRIGHTEXTEND 2311 +#define SCI_HOME 2312 +#define SCI_HOMEEXTEND 2313 +#define SCI_LINEEND 2314 +#define SCI_LINEENDEXTEND 2315 +#define SCI_DOCUMENTSTART 2316 +#define SCI_DOCUMENTSTARTEXTEND 2317 +#define SCI_DOCUMENTEND 2318 +#define SCI_DOCUMENTENDEXTEND 2319 +#define SCI_PAGEUP 2320 +#define SCI_PAGEUPEXTEND 2321 +#define SCI_PAGEDOWN 2322 +#define SCI_PAGEDOWNEXTEND 2323 +#define SCI_EDITTOGGLEOVERTYPE 2324 +#define SCI_CANCEL 2325 +#define SCI_DELETEBACK 2326 +#define SCI_TAB 2327 +#define SCI_BACKTAB 2328 +#define SCI_NEWLINE 2329 +#define SCI_FORMFEED 2330 +#define SCI_VCHOME 2331 +#define SCI_VCHOMEEXTEND 2332 +#define SCI_ZOOMIN 2333 +#define SCI_ZOOMOUT 2334 +#define SCI_DELWORDLEFT 2335 +#define SCI_DELWORDRIGHT 2336 +#define SCI_DELWORDRIGHTEND 2518 +#define SCI_LINECUT 2337 +#define SCI_LINEDELETE 2338 +#define SCI_LINETRANSPOSE 2339 +#define SCI_LINEDUPLICATE 2404 +#define SCI_LOWERCASE 2340 +#define SCI_UPPERCASE 2341 +#define SCI_LINESCROLLDOWN 2342 +#define SCI_LINESCROLLUP 2343 +#define SCI_DELETEBACKNOTLINE 2344 +#define SCI_HOMEDISPLAY 2345 +#define SCI_HOMEDISPLAYEXTEND 2346 +#define SCI_LINEENDDISPLAY 2347 +#define SCI_LINEENDDISPLAYEXTEND 2348 +#define SCI_HOMEWRAP 2349 +#define SCI_HOMEWRAPEXTEND 2450 +#define SCI_LINEENDWRAP 2451 +#define SCI_LINEENDWRAPEXTEND 2452 +#define SCI_VCHOMEWRAP 2453 +#define SCI_VCHOMEWRAPEXTEND 2454 +#define SCI_LINECOPY 2455 +#define SCI_MOVECARETINSIDEVIEW 2401 +#define SCI_LINELENGTH 2350 +#define SCI_BRACEHIGHLIGHT 2351 +#define SCI_BRACEBADLIGHT 2352 +#define SCI_BRACEMATCH 2353 +#define SCI_GETVIEWEOL 2355 +#define SCI_SETVIEWEOL 2356 +#define SCI_GETDOCPOINTER 2357 +#define SCI_SETDOCPOINTER 2358 +#define SCI_SETMODEVENTMASK 2359 +#define EDGE_NONE 0 +#define EDGE_LINE 1 +#define EDGE_BACKGROUND 2 +#define SCI_GETEDGECOLUMN 2360 +#define SCI_SETEDGECOLUMN 2361 +#define SCI_GETEDGEMODE 2362 +#define SCI_SETEDGEMODE 2363 +#define SCI_GETEDGECOLOUR 2364 +#define SCI_SETEDGECOLOUR 2365 +#define SCI_SEARCHANCHOR 2366 +#define SCI_SEARCHNEXT 2367 +#define SCI_SEARCHPREV 2368 +#define SCI_LINESONSCREEN 2370 +#define SCI_USEPOPUP 2371 +#define SCI_SELECTIONISRECTANGLE 2372 +#define SCI_SETZOOM 2373 +#define SCI_GETZOOM 2374 +#define SCI_CREATEDOCUMENT 2375 +#define SCI_ADDREFDOCUMENT 2376 +#define SCI_RELEASEDOCUMENT 2377 +#define SCI_GETMODEVENTMASK 2378 +#define SCI_SETFOCUS 2380 +#define SCI_GETFOCUS 2381 +#define SC_STATUS_OK 0 +#define SC_STATUS_FAILURE 1 +#define SC_STATUS_BADALLOC 2 +#define SCI_SETSTATUS 2382 +#define SCI_GETSTATUS 2383 +#define SCI_SETMOUSEDOWNCAPTURES 2384 +#define SCI_GETMOUSEDOWNCAPTURES 2385 +#define SC_CURSORNORMAL -1 +#define SC_CURSORWAIT 4 +#define SCI_SETCURSOR 2386 +#define SCI_GETCURSOR 2387 +#define SCI_SETCONTROLCHARSYMBOL 2388 +#define SCI_GETCONTROLCHARSYMBOL 2389 +#define SCI_WORDPARTLEFT 2390 +#define SCI_WORDPARTLEFTEXTEND 2391 +#define SCI_WORDPARTRIGHT 2392 +#define SCI_WORDPARTRIGHTEXTEND 2393 +#define VISIBLE_SLOP 0x01 +#define VISIBLE_STRICT 0x04 +#define SCI_SETVISIBLEPOLICY 2394 +#define SCI_DELLINELEFT 2395 +#define SCI_DELLINERIGHT 2396 +#define SCI_SETXOFFSET 2397 +#define SCI_GETXOFFSET 2398 +#define SCI_CHOOSECARETX 2399 +#define SCI_GRABFOCUS 2400 +#define CARET_SLOP 0x01 +#define CARET_STRICT 0x04 +#define CARET_JUMPS 0x10 +#define CARET_EVEN 0x08 +#define SCI_SETXCARETPOLICY 2402 +#define SCI_SETYCARETPOLICY 2403 +#define SCI_SETPRINTWRAPMODE 2406 +#define SCI_GETPRINTWRAPMODE 2407 +#define SCI_SETHOTSPOTACTIVEFORE 2410 +#define SCI_GETHOTSPOTACTIVEFORE 2494 +#define SCI_SETHOTSPOTACTIVEBACK 2411 +#define SCI_GETHOTSPOTACTIVEBACK 2495 +#define SCI_SETHOTSPOTACTIVEUNDERLINE 2412 +#define SCI_GETHOTSPOTACTIVEUNDERLINE 2496 +#define SCI_SETHOTSPOTSINGLELINE 2421 +#define SCI_GETHOTSPOTSINGLELINE 2497 +#define SCI_PARADOWN 2413 +#define SCI_PARADOWNEXTEND 2414 +#define SCI_PARAUP 2415 +#define SCI_PARAUPEXTEND 2416 +#define SCI_POSITIONBEFORE 2417 +#define SCI_POSITIONAFTER 2418 +#define SCI_COPYRANGE 2419 +#define SCI_COPYTEXT 2420 +#define SC_SEL_STREAM 0 +#define SC_SEL_RECTANGLE 1 +#define SC_SEL_LINES 2 +#define SC_SEL_THIN 3 +#define SCI_SETSELECTIONMODE 2422 +#define SCI_GETSELECTIONMODE 2423 +#define SCI_GETLINESELSTARTPOSITION 2424 +#define SCI_GETLINESELENDPOSITION 2425 +#define SCI_LINEDOWNRECTEXTEND 2426 +#define SCI_LINEUPRECTEXTEND 2427 +#define SCI_CHARLEFTRECTEXTEND 2428 +#define SCI_CHARRIGHTRECTEXTEND 2429 +#define SCI_HOMERECTEXTEND 2430 +#define SCI_VCHOMERECTEXTEND 2431 +#define SCI_LINEENDRECTEXTEND 2432 +#define SCI_PAGEUPRECTEXTEND 2433 +#define SCI_PAGEDOWNRECTEXTEND 2434 +#define SCI_STUTTEREDPAGEUP 2435 +#define SCI_STUTTEREDPAGEUPEXTEND 2436 +#define SCI_STUTTEREDPAGEDOWN 2437 +#define SCI_STUTTEREDPAGEDOWNEXTEND 2438 +#define SCI_WORDLEFTEND 2439 +#define SCI_WORDLEFTENDEXTEND 2440 +#define SCI_WORDRIGHTEND 2441 +#define SCI_WORDRIGHTENDEXTEND 2442 +#define SCI_SETWHITESPACECHARS 2443 +#define SCI_SETCHARSDEFAULT 2444 +#define SCI_AUTOCGETCURRENT 2445 +#define SCI_AUTOCGETCURRENTTEXT 2610 +#define SCI_ALLOCATE 2446 +#define SCI_TARGETASUTF8 2447 +#define SCI_SETLENGTHFORENCODE 2448 +#define SCI_ENCODEDFROMUTF8 2449 +#define SCI_FINDCOLUMN 2456 +#define SCI_GETCARETSTICKY 2457 +#define SCI_SETCARETSTICKY 2458 +#define SCI_TOGGLECARETSTICKY 2459 +#define SCI_SETPASTECONVERTENDINGS 2467 +#define SCI_GETPASTECONVERTENDINGS 2468 +#define SCI_SELECTIONDUPLICATE 2469 +#define SC_ALPHA_TRANSPARENT 0 +#define SC_ALPHA_OPAQUE 255 +#define SC_ALPHA_NOALPHA 256 +#define SCI_SETCARETLINEBACKALPHA 2470 +#define SCI_GETCARETLINEBACKALPHA 2471 +#define CARETSTYLE_INVISIBLE 0 +#define CARETSTYLE_LINE 1 +#define CARETSTYLE_BLOCK 2 +#define SCI_SETCARETSTYLE 2512 +#define SCI_GETCARETSTYLE 2513 +#define SCI_SETINDICATORCURRENT 2500 +#define SCI_GETINDICATORCURRENT 2501 +#define SCI_SETINDICATORVALUE 2502 +#define SCI_GETINDICATORVALUE 2503 +#define SCI_INDICATORFILLRANGE 2504 +#define SCI_INDICATORCLEARRANGE 2505 +#define SCI_INDICATORALLONFOR 2506 +#define SCI_INDICATORVALUEAT 2507 +#define SCI_INDICATORSTART 2508 +#define SCI_INDICATOREND 2509 +#define SCI_SETPOSITIONCACHE 2514 +#define SCI_GETPOSITIONCACHE 2515 +#define SCI_COPYALLOWLINE 2519 +#define SCI_GETCHARACTERPOINTER 2520 +#define SCI_SETKEYSUNICODE 2521 +#define SCI_GETKEYSUNICODE 2522 +#define SCI_INDICSETALPHA 2523 +#define SCI_INDICGETALPHA 2524 +#define SCI_SETEXTRAASCENT 2525 +#define SCI_GETEXTRAASCENT 2526 +#define SCI_SETEXTRADESCENT 2527 +#define SCI_GETEXTRADESCENT 2528 +#define SCI_MARKERSYMBOLDEFINED 2529 +#define SCI_MARGINSETTEXT 2530 +#define SCI_MARGINGETTEXT 2531 +#define SCI_MARGINSETSTYLE 2532 +#define SCI_MARGINGETSTYLE 2533 +#define SCI_MARGINSETSTYLES 2534 +#define SCI_MARGINGETSTYLES 2535 +#define SCI_MARGINTEXTCLEARALL 2536 +#define SCI_MARGINSETSTYLEOFFSET 2537 +#define SCI_MARGINGETSTYLEOFFSET 2538 +#define SCI_ANNOTATIONSETTEXT 2540 +#define SCI_ANNOTATIONGETTEXT 2541 +#define SCI_ANNOTATIONSETSTYLE 2542 +#define SCI_ANNOTATIONGETSTYLE 2543 +#define SCI_ANNOTATIONSETSTYLES 2544 +#define SCI_ANNOTATIONGETSTYLES 2545 +#define SCI_ANNOTATIONGETLINES 2546 +#define SCI_ANNOTATIONCLEARALL 2547 +#define ANNOTATION_HIDDEN 0 +#define ANNOTATION_STANDARD 1 +#define ANNOTATION_BOXED 2 +#define SCI_ANNOTATIONSETVISIBLE 2548 +#define SCI_ANNOTATIONGETVISIBLE 2549 +#define SCI_ANNOTATIONSETSTYLEOFFSET 2550 +#define SCI_ANNOTATIONGETSTYLEOFFSET 2551 +#define UNDO_MAY_COALESCE 1 +#define SCI_ADDUNDOACTION 2560 +#define SCI_CHARPOSITIONFROMPOINT 2561 +#define SCI_CHARPOSITIONFROMPOINTCLOSE 2562 +#define SCI_SETMULTIPLESELECTION 2563 +#define SCI_GETMULTIPLESELECTION 2564 +#define SCI_SETADDITIONALSELECTIONTYPING 2565 +#define SCI_GETADDITIONALSELECTIONTYPING 2566 +#define SCI_SETADDITIONALCARETSBLINK 2567 +#define SCI_GETADDITIONALCARETSBLINK 2568 +#define SCI_SETADDITIONALCARETSVISIBLE 2608 +#define SCI_GETADDITIONALCARETSVISIBLE 2609 +#define SCI_GETSELECTIONS 2570 +#define SCI_CLEARSELECTIONS 2571 +#define SCI_SETSELECTION 2572 +#define SCI_ADDSELECTION 2573 +#define SCI_SETMAINSELECTION 2574 +#define SCI_GETMAINSELECTION 2575 +#define SCI_SETSELECTIONNCARET 2576 +#define SCI_GETSELECTIONNCARET 2577 +#define SCI_SETSELECTIONNANCHOR 2578 +#define SCI_GETSELECTIONNANCHOR 2579 +#define SCI_SETSELECTIONNCARETVIRTUALSPACE 2580 +#define SCI_GETSELECTIONNCARETVIRTUALSPACE 2581 +#define SCI_SETSELECTIONNANCHORVIRTUALSPACE 2582 +#define SCI_GETSELECTIONNANCHORVIRTUALSPACE 2583 +#define SCI_SETSELECTIONNSTART 2584 +#define SCI_GETSELECTIONNSTART 2585 +#define SCI_SETSELECTIONNEND 2586 +#define SCI_GETSELECTIONNEND 2587 +#define SCI_SETRECTANGULARSELECTIONCARET 2588 +#define SCI_GETRECTANGULARSELECTIONCARET 2589 +#define SCI_SETRECTANGULARSELECTIONANCHOR 2590 +#define SCI_GETRECTANGULARSELECTIONANCHOR 2591 +#define SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE 2592 +#define SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE 2593 +#define SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE 2594 +#define SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE 2595 +#define SCVS_NONE 0 +#define SCVS_RECTANGULARSELECTION 1 +#define SCVS_USERACCESSIBLE 2 +#define SCI_SETVIRTUALSPACEOPTIONS 2596 +#define SCI_GETVIRTUALSPACEOPTIONS 2597 +#define SCI_SETRECTANGULARSELECTIONMODIFIER 2598 +#define SCI_GETRECTANGULARSELECTIONMODIFIER 2599 +#define SCI_SETADDITIONALSELFORE 2600 +#define SCI_SETADDITIONALSELBACK 2601 +#define SCI_SETADDITIONALSELALPHA 2602 +#define SCI_GETADDITIONALSELALPHA 2603 +#define SCI_SETADDITIONALCARETFORE 2604 +#define SCI_GETADDITIONALCARETFORE 2605 +#define SCI_ROTATESELECTION 2606 +#define SCI_SWAPMAINANCHORCARET 2607 +#define SCI_STARTRECORD 3001 +#define SCI_STOPRECORD 3002 +#define SCI_SETLEXER 4001 +#define SCI_GETLEXER 4002 +#define SCI_COLOURISE 4003 +#define SCI_SETPROPERTY 4004 +#define KEYWORDSET_MAX 8 +#define SCI_SETKEYWORDS 4005 +#define SCI_SETLEXERLANGUAGE 4006 +#define SCI_LOADLEXERLIBRARY 4007 +#define SCI_GETPROPERTY 4008 +#define SCI_GETPROPERTYEXPANDED 4009 +#define SCI_GETPROPERTYINT 4010 +#define SCI_GETSTYLEBITSNEEDED 4011 +#define SCI_GETLEXERLANGUAGE 4012 +#define SC_MOD_INSERTTEXT 0x1 +#define SC_MOD_DELETETEXT 0x2 +#define SC_MOD_CHANGESTYLE 0x4 +#define SC_MOD_CHANGEFOLD 0x8 +#define SC_PERFORMED_USER 0x10 +#define SC_PERFORMED_UNDO 0x20 +#define SC_PERFORMED_REDO 0x40 +#define SC_MULTISTEPUNDOREDO 0x80 +#define SC_LASTSTEPINUNDOREDO 0x100 +#define SC_MOD_CHANGEMARKER 0x200 +#define SC_MOD_BEFOREINSERT 0x400 +#define SC_MOD_BEFOREDELETE 0x800 +#define SC_MULTILINEUNDOREDO 0x1000 +#define SC_STARTACTION 0x2000 +#define SC_MOD_CHANGEINDICATOR 0x4000 +#define SC_MOD_CHANGELINESTATE 0x8000 +#define SC_MOD_CHANGEMARGIN 0x10000 +#define SC_MOD_CHANGEANNOTATION 0x20000 +#define SC_MOD_CONTAINER 0x40000 +#define SC_MODEVENTMASKALL 0x7FFFF +#define SCEN_CHANGE 768 +#define SCEN_SETFOCUS 512 +#define SCEN_KILLFOCUS 256 +#define SCK_DOWN 300 +#define SCK_UP 301 +#define SCK_LEFT 302 +#define SCK_RIGHT 303 +#define SCK_HOME 304 +#define SCK_END 305 +#define SCK_PRIOR 306 +#define SCK_NEXT 307 +#define SCK_DELETE 308 +#define SCK_INSERT 309 +#define SCK_ESCAPE 7 +#define SCK_BACK 8 +#define SCK_TAB 9 +#define SCK_RETURN 13 +#define SCK_ADD 310 +#define SCK_SUBTRACT 311 +#define SCK_DIVIDE 312 +#define SCK_WIN 313 +#define SCK_RWIN 314 +#define SCK_MENU 315 +#define SCMOD_NORM 0 +#define SCMOD_SHIFT 1 +#define SCMOD_CTRL 2 +#define SCMOD_ALT 4 +#define SCMOD_SUPER 8 +#define SCN_STYLENEEDED 2000 +#define SCN_CHARADDED 2001 +#define SCN_SAVEPOINTREACHED 2002 +#define SCN_SAVEPOINTLEFT 2003 +#define SCN_MODIFYATTEMPTRO 2004 +#define SCN_KEY 2005 +#define SCN_DOUBLECLICK 2006 +#define SCN_UPDATEUI 2007 +#define SCN_MODIFIED 2008 +#define SCN_MACRORECORD 2009 +#define SCN_MARGINCLICK 2010 +#define SCN_NEEDSHOWN 2011 +#define SCN_PAINTED 2013 +#define SCN_USERLISTSELECTION 2014 +#define SCN_URIDROPPED 2015 +#define SCN_DWELLSTART 2016 +#define SCN_DWELLEND 2017 +#define SCN_ZOOM 2018 +#define SCN_HOTSPOTCLICK 2019 +#define SCN_HOTSPOTDOUBLECLICK 2020 +#define SCN_CALLTIPCLICK 2021 +#define SCN_AUTOCSELECTION 2022 +#define SCN_INDICATORCLICK 2023 +#define SCN_INDICATORRELEASE 2024 +#define SCN_AUTOCCANCELLED 2025 +#define SCN_AUTOCCHARDELETED 2026 +/* --Autogenerated -- end of section automatically generated from Scintilla.iface */ + +/* These structures are defined to be exactly the same shape as the Win32 + * CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs. + * So older code that treats Scintilla as a RichEdit will work. */ + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +struct Sci_CharacterRange { + long cpMin; + long cpMax; +}; + +struct Sci_TextRange { + struct Sci_CharacterRange chrg; + char *lpstrText; +}; + +struct Sci_TextToFind { + struct Sci_CharacterRange chrg; + char *lpstrText; + struct Sci_CharacterRange chrgText; +}; + +#define CharacterRange Sci_CharacterRange +#define TextRange Sci_TextRange +#define TextToFind Sci_TextToFind + +typedef void *Sci_SurfaceID; + +struct Sci_Rectangle { + int left; + int top; + int right; + int bottom; +}; + +/* This structure is used in printing and requires some of the graphics types + * from Platform.h. Not needed by most client code. */ + +struct Sci_RangeToFormat { + Sci_SurfaceID hdc; + Sci_SurfaceID hdcTarget; + struct Sci_Rectangle rc; + struct Sci_Rectangle rcPage; + struct Sci_CharacterRange chrg; +}; + +#define RangeToFormat Sci_RangeToFormat + +struct Sci_NotifyHeader { + /* Compatible with Windows NMHDR. + * hwndFrom is really an environment specific window handle or pointer + * but most clients of Scintilla.h do not have this type visible. */ + void *hwndFrom; + uptr_t idFrom; + unsigned int code; +}; + +#define NotifyHeader Sci_NotifyHeader + +struct SCNotification { + struct Sci_NotifyHeader nmhdr; + int position; /* SCN_STYLENEEDED, SCN_MODIFIED, SCN_DWELLSTART, SCN_DWELLEND */ + int ch; /* SCN_CHARADDED, SCN_KEY */ + int modifiers; /* SCN_KEY */ + int modificationType; /* SCN_MODIFIED */ + const char *text; /* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION */ + int length; /* SCN_MODIFIED */ + int linesAdded; /* SCN_MODIFIED */ + int message; /* SCN_MACRORECORD */ + uptr_t wParam; /* SCN_MACRORECORD */ + sptr_t lParam; /* SCN_MACRORECORD */ + int line; /* SCN_MODIFIED */ + int foldLevelNow; /* SCN_MODIFIED */ + int foldLevelPrev; /* SCN_MODIFIED */ + int margin; /* SCN_MARGINCLICK */ + int listType; /* SCN_USERLISTSELECTION */ + int x; /* SCN_DWELLSTART, SCN_DWELLEND */ + int y; /* SCN_DWELLSTART, SCN_DWELLEND */ + int token; /* SCN_MODIFIED with SC_MOD_CONTAINER */ + int annotationLinesAdded; /* SC_MOD_CHANGEANNOTATION */ +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/include/Scintilla.iface b/sdk/wxscintilla/src/scintilla/include/Scintilla.iface new file mode 100644 index 0000000..7d64f2d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/Scintilla.iface @@ -0,0 +1,3784 @@ +## First line may be used for shbang + +## This file defines the interface to Scintilla + +## Copyright 2000-2003 by Neil Hodgson +## The License.txt file describes the conditions under which this software may be distributed. + +## A line starting with ## is a pure comment and should be stripped by readers. +## A line starting with #! is for future shbang use +## A line starting with # followed by a space is a documentation comment and refers +## to the next feature definition. + +## Each feature is defined by a line starting with fun, get, set, val or evt. +## cat -> start a category +## fun -> a function +## get -> a property get function +## set -> a property set function +## val -> definition of a constant +## evt -> an event +## enu -> associate an enumeration with a set of vals with a prefix +## lex -> associate a lexer with the lexical classes it produces +## +## All other feature names should be ignored. They may be defined in the future. +## A property may have a set function, a get function or both. Each will have +## "Get" or "Set" in their names and the corresponding name will have the obvious switch. +## A property may be subscripted, in which case the first parameter is the subscript. +## fun, get, and set features have a strict syntax: +## [=,) +## where stands for white space. +## param may be empty (null value) or is [=] +## Additional white space is allowed between elements. +## The syntax for evt is [=[,]*]) +## Feature names that contain an underscore are defined by Windows, so in these +## cases, using the Windows definition is preferred where available. +## The feature numbers are stable so features will not be renumbered. +## Features may be removed but they will go through a period of deprecation +## before removal which is signalled by moving them into the Deprecated category. +## +## enu has the syntax enu=[]* where all the val +## features in this file starting with a given are considered part of the +## enumeration. +## +## lex has the syntax lex=[]* +## where name is a reasonably capitalised (Python, XML) identifier or UI name, +## lexerVal is the val used to specify the lexer, and the list of prefixes is similar +## to enu. The name may not be the same as that used within the lexer so the lexerVal +## should be used to tie these entities together. + +## Types: +## void +## int +## bool -> integer, 1=true, 0=false +## position -> integer position in a document +## colour -> colour integer containing red, green and blue bytes. +## string -> pointer to const character +## stringresult -> pointer to character, NULL-> return size of result +## cells -> pointer to array of cells, each cell containing a style byte and character byte +## textrange -> range of a min and a max position with an output string +## findtext -> searchrange, text -> foundposition +## keymod -> integer containing key in low half and modifiers in high half +## formatrange +## Types no longer used: +## findtextex -> searchrange +## charrange -> range of a min and a max position +## charrangeresult -> like charrange, but output param +## countedstring +## point -> x,y +## pointresult -> like point, but output param +## rectangle -> left,top,right,bottom +## Client code should ignore definitions containing types it does not understand, except +## for possibly #defining the constants + +## Line numbers and positions start at 0. +## String arguments may contain NUL ('\0') characters where the calls provide a length +## argument and retrieve NUL characters. All retrieved strings except for those retrieved +## by GetLine also have a NUL appended but client code should calculate the size that +## will be returned rather than relying upon the NUL whenever possible. Allow for the +## extra NUL character when allocating buffers. The size to allocate for a stringresult +## can be determined by calling with a NULL (0) pointer. + +cat Basics + +################################################ +## For Scintilla.h +val INVALID_POSITION=-1 +# Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages +# as many EM_ messages can be used although that use is deprecated. +val SCI_START=2000 +val SCI_OPTIONAL_START=3000 +val SCI_LEXER_START=4000 + +# Add text to the document at current position. +fun void AddText=2001(int length, string text) + +# Add array of cells to document. +fun void AddStyledText=2002(int length, cells c) + +# Insert string at a position. +fun void InsertText=2003(position pos, string text) + +# Delete all text in the document. +fun void ClearAll=2004(,) + +# Set all style bytes to 0, remove all folding information. +fun void ClearDocumentStyle=2005(,) + +# Returns the number of bytes in the document. +get int GetLength=2006(,) + +# Returns the character byte at the position. +get int GetCharAt=2007(position pos,) + +# Returns the position of the caret. +get position GetCurrentPos=2008(,) + +# Returns the position of the opposite end of the selection to the caret. +get position GetAnchor=2009(,) + +# Returns the style byte at the position. +get int GetStyleAt=2010(position pos,) + +# Redoes the next action on the undo history. +fun void Redo=2011(,) + +# Choose between collecting actions into the undo +# history and discarding them. +set void SetUndoCollection=2012(bool collectUndo,) + +# Select all the text in the document. +fun void SelectAll=2013(,) + +# Remember the current position in the undo history as the position +# at which the document was saved. +fun void SetSavePoint=2014(,) + +# Retrieve a buffer of cells. +# Returns the number of bytes in the buffer not including terminating NULs. +fun int GetStyledText=2015(, textrange tr) + +# Are there any redoable actions in the undo history? +fun bool CanRedo=2016(,) + +# Retrieve the line number at which a particular marker is located. +fun int MarkerLineFromHandle=2017(int handle,) + +# Delete a marker. +fun void MarkerDeleteHandle=2018(int handle,) + +# Is undo history being collected? +get bool GetUndoCollection=2019(,) + +enu WhiteSpace=SCWS_ +val SCWS_INVISIBLE=0 +val SCWS_VISIBLEALWAYS=1 +val SCWS_VISIBLEAFTERINDENT=2 + +# Are white space characters currently visible? +# Returns one of SCWS_* constants. +get int GetViewWS=2020(,) + +# Make white space characters invisible, always visible or visible outside indentation. +set void SetViewWS=2021(int viewWS,) + +# Find the position from a point within the window. +fun position PositionFromPoint=2022(int x, int y) + +# Find the position from a point within the window but return +# INVALID_POSITION if not close to text. +fun position PositionFromPointClose=2023(int x, int y) + +# Set caret to start of a line and ensure it is visible. +fun void GotoLine=2024(int line,) + +# Set caret to a position and ensure it is visible. +fun void GotoPos=2025(position pos,) + +# Set the selection anchor to a position. The anchor is the opposite +# end of the selection from the caret. +set void SetAnchor=2026(position posAnchor,) + +# Retrieve the text of the line containing the caret. +# Returns the index of the caret on the line. +fun int GetCurLine=2027(int length, stringresult text) + +# Retrieve the position of the last correctly styled character. +get position GetEndStyled=2028(,) + +enu EndOfLine=SC_EOL_ +val SC_EOL_CRLF=0 +val SC_EOL_CR=1 +val SC_EOL_LF=2 + +# Convert all line endings in the document to one mode. +fun void ConvertEOLs=2029(int eolMode,) + +# Retrieve the current end of line mode - one of CRLF, CR, or LF. +get int GetEOLMode=2030(,) + +# Set the current end of line mode. +set void SetEOLMode=2031(int eolMode,) + +# Set the current styling position to pos and the styling mask to mask. +# The styling mask can be used to protect some bits in each styling byte from modification. +fun void StartStyling=2032(position pos, int mask) + +# Change style from current styling position for length characters to a style +# and move the current styling position to after this newly styled segment. +fun void SetStyling=2033(int length, int style) + +# Is drawing done first into a buffer or direct to the screen? +get bool GetBufferedDraw=2034(,) + +# If drawing is buffered then each line of text is drawn into a bitmap buffer +# before drawing it to the screen to avoid flicker. +set void SetBufferedDraw=2035(bool buffered,) + +# Change the visible size of a tab to be a multiple of the width of a space character. +set void SetTabWidth=2036(int tabWidth,) + +# Retrieve the visible size of a tab. +get int GetTabWidth=2121(,) + +# The SC_CP_UTF8 value can be used to enter Unicode mode. +# This is the same value as CP_UTF8 in Windows +val SC_CP_UTF8=65001 + +# The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+. +val SC_CP_DBCS=1 + +# Set the code page used to interpret the bytes of the document as characters. +# The SC_CP_UTF8 value can be used to enter Unicode mode. +set void SetCodePage=2037(int codePage,) + +# In palette mode, Scintilla uses the environment's palette calls to display +# more colours. This may lead to ugly displays. +set void SetUsePalette=2039(bool usePalette,) + +enu MarkerSymbol=SC_MARK_ +val MARKER_MAX=31 +val SC_MARK_CIRCLE=0 +val SC_MARK_ROUNDRECT=1 +val SC_MARK_ARROW=2 +val SC_MARK_SMALLRECT=3 +val SC_MARK_SHORTARROW=4 +val SC_MARK_EMPTY=5 +val SC_MARK_ARROWDOWN=6 +val SC_MARK_MINUS=7 +val SC_MARK_PLUS=8 + +# Shapes used for outlining column. +val SC_MARK_VLINE=9 +val SC_MARK_LCORNER=10 +val SC_MARK_TCORNER=11 +val SC_MARK_BOXPLUS=12 +val SC_MARK_BOXPLUSCONNECTED=13 +val SC_MARK_BOXMINUS=14 +val SC_MARK_BOXMINUSCONNECTED=15 +val SC_MARK_LCORNERCURVE=16 +val SC_MARK_TCORNERCURVE=17 +val SC_MARK_CIRCLEPLUS=18 +val SC_MARK_CIRCLEPLUSCONNECTED=19 +val SC_MARK_CIRCLEMINUS=20 +val SC_MARK_CIRCLEMINUSCONNECTED=21 + +# Invisible mark that only sets the line background color. +val SC_MARK_BACKGROUND=22 +val SC_MARK_DOTDOTDOT=23 +val SC_MARK_ARROWS=24 +val SC_MARK_PIXMAP=25 +val SC_MARK_FULLRECT=26 +val SC_MARK_LEFTRECT=27 +val SC_MARK_AVAILABLE=28 +val SC_MARK_UNDERLINE=29 + +val SC_MARK_CHARACTER=10000 + +enu MarkerOutline=SC_MARKNUM_ +# Markers used for outlining column. +val SC_MARKNUM_FOLDEREND=25 +val SC_MARKNUM_FOLDEROPENMID=26 +val SC_MARKNUM_FOLDERMIDTAIL=27 +val SC_MARKNUM_FOLDERTAIL=28 +val SC_MARKNUM_FOLDERSUB=29 +val SC_MARKNUM_FOLDER=30 +val SC_MARKNUM_FOLDEROPEN=31 + +val SC_MASK_FOLDERS=0xFE000000 + +# Set the symbol used for a particular marker number. +fun void MarkerDefine=2040(int markerNumber, int markerSymbol) + +# Set the foreground colour used for a particular marker number. +fun void MarkerSetFore=2041(int markerNumber, colour fore) + +# Set the background colour used for a particular marker number. +fun void MarkerSetBack=2042(int markerNumber, colour back) + +# Add a marker to a line, returning an ID which can be used to find or delete the marker. +fun int MarkerAdd=2043(int line, int markerNumber) + +# Delete a marker from a line. +fun void MarkerDelete=2044(int line, int markerNumber) + +# Delete all markers with a particular number from all lines. +fun void MarkerDeleteAll=2045(int markerNumber,) + +# Get a bit mask of all the markers set on a line. +fun int MarkerGet=2046(int line,) + +# Find the next line after lineStart that includes a marker in mask. +fun int MarkerNext=2047(int lineStart, int markerMask) + +# Find the previous line before lineStart that includes a marker in mask. +fun int MarkerPrevious=2048(int lineStart, int markerMask) + +# Define a marker from a pixmap. +fun void MarkerDefinePixmap=2049(int markerNumber, string pixmap) + +# Add a set of markers to a line. +fun void MarkerAddSet=2466(int line, int set) + +# Set the alpha used for a marker that is drawn in the text area, not the margin. +fun void MarkerSetAlpha=2476(int markerNumber, int alpha) + +enu MarginType=SC_MARGIN_ +val SC_MARGIN_SYMBOL=0 +val SC_MARGIN_NUMBER=1 +val SC_MARGIN_BACK=2 +val SC_MARGIN_FORE=3 +val SC_MARGIN_TEXT=4 +val SC_MARGIN_RTEXT=5 + +# Set a margin to be either numeric or symbolic. +set void SetMarginTypeN=2240(int margin, int marginType) + +# Retrieve the type of a margin. +get int GetMarginTypeN=2241(int margin,) + +# Set the width of a margin to a width expressed in pixels. +set void SetMarginWidthN=2242(int margin, int pixelWidth) + +# Retrieve the width of a margin in pixels. +get int GetMarginWidthN=2243(int margin,) + +# Set a mask that determines which markers are displayed in a margin. +set void SetMarginMaskN=2244(int margin, int mask) + +# Retrieve the marker mask of a margin. +get int GetMarginMaskN=2245(int margin,) + +# Make a margin sensitive or insensitive to mouse clicks. +set void SetMarginSensitiveN=2246(int margin, bool sensitive) + +# Retrieve the mouse click sensitivity of a margin. +get bool GetMarginSensitiveN=2247(int margin,) + +# Styles in range 32..38 are predefined for parts of the UI and are not used as normal styles. +# Style 39 is for future use. +enu StylesCommon=STYLE_ +val STYLE_DEFAULT=32 +val STYLE_LINENUMBER=33 +val STYLE_BRACELIGHT=34 +val STYLE_BRACEBAD=35 +val STYLE_CONTROLCHAR=36 +val STYLE_INDENTGUIDE=37 +val STYLE_CALLTIP=38 +val STYLE_LASTPREDEFINED=39 +val STYLE_MAX=255 + +# Character set identifiers are used in StyleSetCharacterSet. +# The values are the same as the Windows *_CHARSET values. +enu CharacterSet=SC_CHARSET_ +val SC_CHARSET_ANSI=0 +val SC_CHARSET_DEFAULT=1 +val SC_CHARSET_BALTIC=186 +val SC_CHARSET_CHINESEBIG5=136 +val SC_CHARSET_EASTEUROPE=238 +val SC_CHARSET_GB2312=134 +val SC_CHARSET_GREEK=161 +val SC_CHARSET_HANGUL=129 +val SC_CHARSET_MAC=77 +val SC_CHARSET_OEM=255 +val SC_CHARSET_RUSSIAN=204 +val SC_CHARSET_CYRILLIC=1251 +val SC_CHARSET_SHIFTJIS=128 +val SC_CHARSET_SYMBOL=2 +val SC_CHARSET_TURKISH=162 +val SC_CHARSET_JOHAB=130 +val SC_CHARSET_HEBREW=177 +val SC_CHARSET_ARABIC=178 +val SC_CHARSET_VIETNAMESE=163 +val SC_CHARSET_THAI=222 +val SC_CHARSET_8859_15=1000 + +# Clear all the styles and make equivalent to the global default style. +set void StyleClearAll=2050(,) + +# Set the foreground colour of a style. +set void StyleSetFore=2051(int style, colour fore) + +# Set the background colour of a style. +set void StyleSetBack=2052(int style, colour back) + +# Set a style to be bold or not. +set void StyleSetBold=2053(int style, bool bold) + +# Set a style to be italic or not. +set void StyleSetItalic=2054(int style, bool italic) + +# Set the size of characters of a style. +set void StyleSetSize=2055(int style, int sizePoints) + +# Set the font of a style. +set void StyleSetFont=2056(int style, string fontName) + +# Set a style to have its end of line filled or not. +set void StyleSetEOLFilled=2057(int style, bool filled) + +# Reset the default style to its state at startup +fun void StyleResetDefault=2058(,) + +# Set a style to be underlined or not. +set void StyleSetUnderline=2059(int style, bool underline) + +enu CaseVisible=SC_CASE_ +val SC_CASE_MIXED=0 +val SC_CASE_UPPER=1 +val SC_CASE_LOWER=2 + +# Get the foreground colour of a style. +get colour StyleGetFore=2481(int style,) + +# Get the background colour of a style. +get colour StyleGetBack=2482(int style,) + +# Get is a style bold or not. +get bool StyleGetBold=2483(int style,) + +# Get is a style italic or not. +get bool StyleGetItalic=2484(int style,) + +# Get the size of characters of a style. +get int StyleGetSize=2485(int style,) + +# Get the font of a style. +# Returns the length of the fontName +fun int StyleGetFont=2486(int style, stringresult fontName) + +# Get is a style to have its end of line filled or not. +get bool StyleGetEOLFilled=2487(int style,) + +# Get is a style underlined or not. +get bool StyleGetUnderline=2488(int style,) + +# Get is a style mixed case, or to force upper or lower case. +get int StyleGetCase=2489(int style,) + +# Get the character get of the font in a style. +get int StyleGetCharacterSet=2490(int style,) + +# Get is a style visible or not. +get bool StyleGetVisible=2491(int style,) + +# Get is a style changeable or not (read only). +# Experimental feature, currently buggy. +get bool StyleGetChangeable=2492(int style,) + +# Get is a style a hotspot or not. +get bool StyleGetHotSpot=2493(int style,) + +# Set a style to be mixed case, or to force upper or lower case. +set void StyleSetCase=2060(int style, int caseForce) + +# Set the character set of the font in a style. +set void StyleSetCharacterSet=2066(int style, int characterSet) + +# Set a style to be a hotspot or not. +set void StyleSetHotSpot=2409(int style, bool hotspot) + +# Set the foreground colour of the main and additional selections and whether to use this setting. +fun void SetSelFore=2067(bool useSetting, colour fore) + +# Set the background colour of the main and additional selections and whether to use this setting. +fun void SetSelBack=2068(bool useSetting, colour back) + +# Get the alpha of the selection. +get int GetSelAlpha=2477(,) + +# Set the alpha of the selection. +set void SetSelAlpha=2478(int alpha,) + +# Is the selection end of line filled? +get bool GetSelEOLFilled=2479(,) + +# Set the selection to have its end of line filled or not. +set void SetSelEOLFilled=2480(bool filled,) + +# Set the foreground colour of the caret. +set void SetCaretFore=2069(colour fore,) + +# When key+modifier combination km is pressed perform msg. +fun void AssignCmdKey=2070(keymod km, int msg) + +# When key+modifier combination km is pressed do nothing. +fun void ClearCmdKey=2071(keymod km,) + +# Drop all key mappings. +fun void ClearAllCmdKeys=2072(,) + +# Set the styles for a segment of the document. +fun void SetStylingEx=2073(int length, string styles) + +# Set a style to be visible or not. +set void StyleSetVisible=2074(int style, bool visible) + +# Get the time in milliseconds that the caret is on and off. +get int GetCaretPeriod=2075(,) + +# Get the time in milliseconds that the caret is on and off. 0 = steady on. +set void SetCaretPeriod=2076(int periodMilliseconds,) + +# Set the set of characters making up words for when moving or selecting by word. +# First sets defaults like SetCharsDefault. +set void SetWordChars=2077(, string characters) + +# Start a sequence of actions that is undone and redone as a unit. +# May be nested. +fun void BeginUndoAction=2078(,) + +# End a sequence of actions that is undone and redone as a unit. +fun void EndUndoAction=2079(,) + +# Indicator style enumeration and some constants +enu IndicatorStyle=INDIC_ +val INDIC_PLAIN=0 +val INDIC_SQUIGGLE=1 +val INDIC_TT=2 +val INDIC_DIAGONAL=3 +val INDIC_STRIKE=4 +val INDIC_HIDDEN=5 +val INDIC_BOX=6 +val INDIC_ROUNDBOX=7 +val INDIC_MAX=31 +val INDIC_CONTAINER=8 +val INDIC0_MASK=0x20 +val INDIC1_MASK=0x40 +val INDIC2_MASK=0x80 +val INDICS_MASK=0xE0 + +# Set an indicator to plain, squiggle or TT. +set void IndicSetStyle=2080(int indic, int style) + +# Retrieve the style of an indicator. +get int IndicGetStyle=2081(int indic,) + +# Set the foreground colour of an indicator. +set void IndicSetFore=2082(int indic, colour fore) + +# Retrieve the foreground colour of an indicator. +get colour IndicGetFore=2083(int indic,) + +# Set an indicator to draw under text or over(default). +set void IndicSetUnder=2510(int indic, bool under) + +# Retrieve whether indicator drawn under or over text. +get bool IndicGetUnder=2511(int indic,) + +# Set the foreground colour of all whitespace and whether to use this setting. +fun void SetWhitespaceFore=2084(bool useSetting, colour fore) + +# Set the background colour of all whitespace and whether to use this setting. +fun void SetWhitespaceBack=2085(bool useSetting, colour back) + +# Set the size of the dots used to mark space characters. +set void SetWhitespaceSize=2086(int size,) + +# Get the size of the dots used to mark space characters. +get int GetWhitespaceSize=2087(,) + +# Divide each styling byte into lexical class bits (default: 5) and indicator +# bits (default: 3). If a lexer requires more than 32 lexical states, then this +# is used to expand the possible states. +set void SetStyleBits=2090(int bits,) + +# Retrieve number of bits in style bytes used to hold the lexical state. +get int GetStyleBits=2091(,) + +# Used to hold extra styling information for each line. +set void SetLineState=2092(int line, int state) + +# Retrieve the extra styling information for a line. +get int GetLineState=2093(int line,) + +# Retrieve the last line number that has line state. +get int GetMaxLineState=2094(,) + +# Is the background of the line containing the caret in a different colour? +get bool GetCaretLineVisible=2095(,) + +# Display the background of the line containing the caret in a different colour. +set void SetCaretLineVisible=2096(bool show,) + +# Get the colour of the background of the line containing the caret. +get colour GetCaretLineBack=2097(,) + +# Set the colour of the background of the line containing the caret. +set void SetCaretLineBack=2098(colour back,) + +# Set a style to be changeable or not (read only). +# Experimental feature, currently buggy. +set void StyleSetChangeable=2099(int style, bool changeable) + +# Display a auto-completion list. +# The lenEntered parameter indicates how many characters before +# the caret should be used to provide context. +fun void AutoCShow=2100(int lenEntered, string itemList) + +# Remove the auto-completion list from the screen. +fun void AutoCCancel=2101(,) + +# Is there an auto-completion list visible? +fun bool AutoCActive=2102(,) + +# Retrieve the position of the caret when the auto-completion list was displayed. +fun position AutoCPosStart=2103(,) + +# User has selected an item so remove the list and insert the selection. +fun void AutoCComplete=2104(,) + +# Define a set of character that when typed cancel the auto-completion list. +fun void AutoCStops=2105(, string characterSet) + +# Change the separator character in the string setting up an auto-completion list. +# Default is space but can be changed if items contain space. +set void AutoCSetSeparator=2106(int separatorCharacter,) + +# Retrieve the auto-completion list separator character. +get int AutoCGetSeparator=2107(,) + +# Select the item in the auto-completion list that starts with a string. +fun void AutoCSelect=2108(, string text) + +# Should the auto-completion list be cancelled if the user backspaces to a +# position before where the box was created. +set void AutoCSetCancelAtStart=2110(bool cancel,) + +# Retrieve whether auto-completion cancelled by backspacing before start. +get bool AutoCGetCancelAtStart=2111(,) + +# Define a set of characters that when typed will cause the autocompletion to +# choose the selected item. +set void AutoCSetFillUps=2112(, string characterSet) + +# Should a single item auto-completion list automatically choose the item. +set void AutoCSetChooseSingle=2113(bool chooseSingle,) + +# Retrieve whether a single item auto-completion list automatically choose the item. +get bool AutoCGetChooseSingle=2114(,) + +# Set whether case is significant when performing auto-completion searches. +set void AutoCSetIgnoreCase=2115(bool ignoreCase,) + +# Retrieve state of ignore case flag. +get bool AutoCGetIgnoreCase=2116(,) + +# Display a list of strings and send notification when user chooses one. +fun void UserListShow=2117(int listType, string itemList) + +# Set whether or not autocompletion is hidden automatically when nothing matches. +set void AutoCSetAutoHide=2118(bool autoHide,) + +# Retrieve whether or not autocompletion is hidden automatically when nothing matches. +get bool AutoCGetAutoHide=2119(,) + +# Set whether or not autocompletion deletes any word characters +# after the inserted text upon completion. +set void AutoCSetDropRestOfWord=2270(bool dropRestOfWord,) + +# Retrieve whether or not autocompletion deletes any word characters +# after the inserted text upon completion. +get bool AutoCGetDropRestOfWord=2271(,) + +# Register an XPM image for use in autocompletion lists. +fun void RegisterImage=2405(int type, string xpmData) + +# Clear all the registered XPM images. +fun void ClearRegisteredImages=2408(,) + +# Retrieve the auto-completion list type-separator character. +get int AutoCGetTypeSeparator=2285(,) + +# Change the type-separator character in the string setting up an auto-completion list. +# Default is '?' but can be changed if items contain '?'. +set void AutoCSetTypeSeparator=2286(int separatorCharacter,) + +# Set the maximum width, in characters, of auto-completion and user lists. +# Set to 0 to autosize to fit longest item, which is the default. +set void AutoCSetMaxWidth=2208(int characterCount,) + +# Get the maximum width, in characters, of auto-completion and user lists. +get int AutoCGetMaxWidth=2209(,) + +# Set the maximum height, in rows, of auto-completion and user lists. +# The default is 5 rows. +set void AutoCSetMaxHeight=2210(int rowCount,) + +# Set the maximum height, in rows, of auto-completion and user lists. +get int AutoCGetMaxHeight=2211(,) + +# Set the number of spaces used for one level of indentation. +set void SetIndent=2122(int indentSize,) + +# Retrieve indentation size. +get int GetIndent=2123(,) + +# Indentation will only use space characters if useTabs is false, otherwise +# it will use a combination of tabs and spaces. +set void SetUseTabs=2124(bool useTabs,) + +# Retrieve whether tabs will be used in indentation. +get bool GetUseTabs=2125(,) + +# Change the indentation of a line to a number of columns. +set void SetLineIndentation=2126(int line, int indentSize) + +# Retrieve the number of columns that a line is indented. +get int GetLineIndentation=2127(int line,) + +# Retrieve the position before the first non indentation character on a line. +get position GetLineIndentPosition=2128(int line,) + +# Retrieve the column number of a position, taking tab width into account. +get int GetColumn=2129(position pos,) + +# Show or hide the horizontal scroll bar. +set void SetHScrollBar=2130(bool show,) + +# Is the horizontal scroll bar visible? +get bool GetHScrollBar=2131(,) + +enu IndentView=SC_IV_ +val SC_IV_NONE=0 +val SC_IV_REAL=1 +val SC_IV_LOOKFORWARD=2 +val SC_IV_LOOKBOTH=3 + +# Show or hide indentation guides. +set void SetIndentationGuides=2132(int indentView,) + +# Are the indentation guides visible? +get int GetIndentationGuides=2133(,) + +# Set the highlighted indentation guide column. +# 0 = no highlighted guide. +set void SetHighlightGuide=2134(int column,) + +# Get the highlighted indentation guide column. +get int GetHighlightGuide=2135(,) + +# Get the position after the last visible characters on a line. +get int GetLineEndPosition=2136(int line,) + +# Get the code page used to interpret the bytes of the document as characters. +get int GetCodePage=2137(,) + +# Get the foreground colour of the caret. +get colour GetCaretFore=2138(,) + +# In palette mode? +get bool GetUsePalette=2139(,) + +# In read-only mode? +get bool GetReadOnly=2140(,) + +# Sets the position of the caret. +set void SetCurrentPos=2141(position pos,) + +# Sets the position that starts the selection - this becomes the anchor. +set void SetSelectionStart=2142(position pos,) + +# Returns the position at the start of the selection. +get position GetSelectionStart=2143(,) + +# Sets the position that ends the selection - this becomes the currentPosition. +set void SetSelectionEnd=2144(position pos,) + +# Returns the position at the end of the selection. +get position GetSelectionEnd=2145(,) + +# Sets the print magnification added to the point size of each style for printing. +set void SetPrintMagnification=2146(int magnification,) + +# Returns the print magnification. +get int GetPrintMagnification=2147(,) + +enu PrintOption=SC_PRINT_ +# PrintColourMode - use same colours as screen. +val SC_PRINT_NORMAL=0 +# PrintColourMode - invert the light value of each style for printing. +val SC_PRINT_INVERTLIGHT=1 +# PrintColourMode - force black text on white background for printing. +val SC_PRINT_BLACKONWHITE=2 +# PrintColourMode - text stays coloured, but all background is forced to be white for printing. +val SC_PRINT_COLOURONWHITE=3 +# PrintColourMode - only the default-background is forced to be white for printing. +val SC_PRINT_COLOURONWHITEDEFAULTBG=4 + +# Modify colours when printing for clearer printed text. +set void SetPrintColourMode=2148(int mode,) + +# Returns the print colour mode. +get int GetPrintColourMode=2149(,) + +enu FindOption=SCFIND_ +val SCFIND_WHOLEWORD=2 +val SCFIND_MATCHCASE=4 +val SCFIND_WORDSTART=0x00100000 +val SCFIND_REGEXP=0x00200000 +val SCFIND_POSIX=0x00400000 + +# Find some text in the document. +fun position FindText=2150(int flags, findtext ft) + +# On Windows, will draw the document into a display context such as a printer. +fun position FormatRange=2151(bool draw, formatrange fr) + +# Retrieve the display line at the top of the display. +get int GetFirstVisibleLine=2152(,) + +# Retrieve the contents of a line. +# Returns the length of the line. +fun int GetLine=2153(int line, stringresult text) + +# Returns the number of lines in the document. There is always at least one. +get int GetLineCount=2154(,) + +# Sets the size in pixels of the left margin. +set void SetMarginLeft=2155(, int pixelWidth) + +# Returns the size in pixels of the left margin. +get int GetMarginLeft=2156(,) + +# Sets the size in pixels of the right margin. +set void SetMarginRight=2157(, int pixelWidth) + +# Returns the size in pixels of the right margin. +get int GetMarginRight=2158(,) + +# Is the document different from when it was last saved? +get bool GetModify=2159(,) + +# Select a range of text. +fun void SetSel=2160(position start, position end) + +# Retrieve the selected text. +# Return the length of the text. +fun int GetSelText=2161(, stringresult text) + +# Retrieve a range of text. +# Return the length of the text. +fun int GetTextRange=2162(, textrange tr) + +# Draw the selection in normal style or with selection highlighted. +fun void HideSelection=2163(bool normal,) + +# Retrieve the x value of the point in the window where a position is displayed. +fun int PointXFromPosition=2164(, position pos) + +# Retrieve the y value of the point in the window where a position is displayed. +fun int PointYFromPosition=2165(, position pos) + +# Retrieve the line containing a position. +fun int LineFromPosition=2166(position pos,) + +# Retrieve the position at the start of a line. +fun position PositionFromLine=2167(int line,) + +# Scroll horizontally and vertically. +fun void LineScroll=2168(int columns, int lines) + +# Ensure the caret is visible. +fun void ScrollCaret=2169(,) + +# Replace the selected text with the argument text. +fun void ReplaceSel=2170(, string text) + +# Set to read only or read write. +set void SetReadOnly=2171(bool readOnly,) + +# Null operation. +fun void Null=2172(,) + +# Will a paste succeed? +fun bool CanPaste=2173(,) + +# Are there any undoable actions in the undo history? +fun bool CanUndo=2174(,) + +# Delete the undo history. +fun void EmptyUndoBuffer=2175(,) + +# Undo one action in the undo history. +fun void Undo=2176(,) + +# Cut the selection to the clipboard. +fun void Cut=2177(,) + +# Copy the selection to the clipboard. +fun void Copy=2178(,) + +# Paste the contents of the clipboard into the document replacing the selection. +fun void Paste=2179(,) + +# Clear the selection. +fun void Clear=2180(,) + +# Replace the contents of the document with the argument text. +fun void SetText=2181(, string text) + +# Retrieve all the text in the document. +# Returns number of characters retrieved. +fun int GetText=2182(int length, stringresult text) + +# Retrieve the number of characters in the document. +get int GetTextLength=2183(,) + +# Retrieve a pointer to a function that processes messages for this Scintilla. +get int GetDirectFunction=2184(,) + +# Retrieve a pointer value to use as the first argument when calling +# the function returned by GetDirectFunction. +get int GetDirectPointer=2185(,) + +# Set to overtype (true) or insert mode. +set void SetOvertype=2186(bool overtype,) + +# Returns true if overtype mode is active otherwise false is returned. +get bool GetOvertype=2187(,) + +# Set the width of the insert mode caret. +set void SetCaretWidth=2188(int pixelWidth,) + +# Returns the width of the insert mode caret. +get int GetCaretWidth=2189(,) + +# Sets the position that starts the target which is used for updating the +# document without affecting the scroll position. +set void SetTargetStart=2190(position pos,) + +# Get the position that starts the target. +get position GetTargetStart=2191(,) + +# Sets the position that ends the target which is used for updating the +# document without affecting the scroll position. +set void SetTargetEnd=2192(position pos,) + +# Get the position that ends the target. +get position GetTargetEnd=2193(,) + +# Replace the target text with the argument text. +# Text is counted so it can contain NULs. +# Returns the length of the replacement text. +fun int ReplaceTarget=2194(int length, string text) + +# Replace the target text with the argument text after \d processing. +# Text is counted so it can contain NULs. +# Looks for \d where d is between 1 and 9 and replaces these with the strings +# matched in the last search operation which were surrounded by \( and \). +# Returns the length of the replacement text including any change +# caused by processing the \d patterns. +fun int ReplaceTargetRE=2195(int length, string text) + +# Search for a counted string in the target and set the target to the found +# range. Text is counted so it can contain NULs. +# Returns length of range or -1 for failure in which case target is not moved. +fun int SearchInTarget=2197(int length, string text) + +# Set the search flags used by SearchInTarget. +set void SetSearchFlags=2198(int flags,) + +# Get the search flags used by SearchInTarget. +get int GetSearchFlags=2199(,) + +# Show a call tip containing a definition near position pos. +fun void CallTipShow=2200(position pos, string definition) + +# Remove the call tip from the screen. +fun void CallTipCancel=2201(,) + +# Is there an active call tip? +fun bool CallTipActive=2202(,) + +# Retrieve the position where the caret was before displaying the call tip. +fun position CallTipPosStart=2203(,) + +# Highlight a segment of the definition. +fun void CallTipSetHlt=2204(int start, int end) + +# Set the background colour for the call tip. +set void CallTipSetBack=2205(colour back,) + +# Set the foreground colour for the call tip. +set void CallTipSetFore=2206(colour fore,) + +# Set the foreground colour for the highlighted part of the call tip. +set void CallTipSetForeHlt=2207(colour fore,) + +# Enable use of STYLE_CALLTIP and set call tip tab size in pixels. +set void CallTipUseStyle=2212(int tabSize,) + +# Find the display line of a document line taking hidden lines into account. +fun int VisibleFromDocLine=2220(int line,) + +# Find the document line of a display line taking hidden lines into account. +fun int DocLineFromVisible=2221(int lineDisplay,) + +# The number of display lines needed to wrap a document line +fun int WrapCount=2235(int line,) + +enu FoldLevel=SC_FOLDLEVEL +val SC_FOLDLEVELBASE=0x400 +val SC_FOLDLEVELWHITEFLAG=0x1000 +val SC_FOLDLEVELHEADERFLAG=0x2000 +val SC_FOLDLEVELNUMBERMASK=0x0FFF + +# Set the fold level of a line. +# This encodes an integer level along with flags indicating whether the +# line is a header and whether it is effectively white space. +set void SetFoldLevel=2222(int line, int level) + +# Retrieve the fold level of a line. +get int GetFoldLevel=2223(int line,) + +# Find the last child line of a header line. +get int GetLastChild=2224(int line, int level) + +# Find the parent line of a child line. +get int GetFoldParent=2225(int line,) + +# Make a range of lines visible. +fun void ShowLines=2226(int lineStart, int lineEnd) + +# Make a range of lines invisible. +fun void HideLines=2227(int lineStart, int lineEnd) + +# Is a line visible? +get bool GetLineVisible=2228(int line,) + +# Show the children of a header line. +set void SetFoldExpanded=2229(int line, bool expanded) + +# Is a header line expanded? +get bool GetFoldExpanded=2230(int line,) + +# Switch a header line between expanded and contracted. +fun void ToggleFold=2231(int line,) + +# Ensure a particular line is visible by expanding any header line hiding it. +fun void EnsureVisible=2232(int line,) + +enu FoldFlag=SC_FOLDFLAG_ +val SC_FOLDFLAG_LINEBEFORE_EXPANDED=0x0002 +val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004 +val SC_FOLDFLAG_LINEAFTER_EXPANDED=0x0008 +val SC_FOLDFLAG_LINEAFTER_CONTRACTED=0x0010 +val SC_FOLDFLAG_LEVELNUMBERS=0x0040 + +# Set some style options for folding. +fun void SetFoldFlags=2233(int flags,) + +# Ensure a particular line is visible by expanding any header line hiding it. +# Use the currently set visibility policy to determine which range to display. +fun void EnsureVisibleEnforcePolicy=2234(int line,) + +# Sets whether a tab pressed when caret is within indentation indents. +set void SetTabIndents=2260(bool tabIndents,) + +# Does a tab pressed when caret is within indentation indent? +get bool GetTabIndents=2261(,) + +# Sets whether a backspace pressed when caret is within indentation unindents. +set void SetBackSpaceUnIndents=2262(bool bsUnIndents,) + +# Does a backspace pressed when caret is within indentation unindent? +get bool GetBackSpaceUnIndents=2263(,) + +val SC_TIME_FOREVER=10000000 + +# Sets the time the mouse must sit still to generate a mouse dwell event. +set void SetMouseDwellTime=2264(int periodMilliseconds,) + +# Retrieve the time the mouse must sit still to generate a mouse dwell event. +get int GetMouseDwellTime=2265(,) + +# Get position of start of word. +fun int WordStartPosition=2266(position pos, bool onlyWordCharacters) + +# Get position of end of word. +fun int WordEndPosition=2267(position pos, bool onlyWordCharacters) + +enu Wrap=SC_WRAP_ +val SC_WRAP_NONE=0 +val SC_WRAP_WORD=1 +val SC_WRAP_CHAR=2 + +# Sets whether text is word wrapped. +set void SetWrapMode=2268(int mode,) + +# Retrieve whether text is word wrapped. +get int GetWrapMode=2269(,) + +enu WrapVisualFlag=SC_WRAPVISUALFLAG_ +val SC_WRAPVISUALFLAG_NONE=0x0000 +val SC_WRAPVISUALFLAG_END=0x0001 +val SC_WRAPVISUALFLAG_START=0x0002 + +# Set the display mode of visual flags for wrapped lines. +set void SetWrapVisualFlags=2460(int wrapVisualFlags,) + +# Retrive the display mode of visual flags for wrapped lines. +get int GetWrapVisualFlags=2461(,) + +enu WrapVisualLocation=SC_WRAPVISUALFLAGLOC_ +val SC_WRAPVISUALFLAGLOC_DEFAULT=0x0000 +val SC_WRAPVISUALFLAGLOC_END_BY_TEXT=0x0001 +val SC_WRAPVISUALFLAGLOC_START_BY_TEXT=0x0002 + +# Set the location of visual flags for wrapped lines. +set void SetWrapVisualFlagsLocation=2462(int wrapVisualFlagsLocation,) + +# Retrive the location of visual flags for wrapped lines. +get int GetWrapVisualFlagsLocation=2463(,) + +# Set the start indent for wrapped lines. +set void SetWrapStartIndent=2464(int indent,) + +# Retrive the start indent for wrapped lines. +get int GetWrapStartIndent=2465(,) + +enu WrapIndentMode=SC_WRAPINDENT_ +val SC_WRAPINDENT_FIXED=0 +val SC_WRAPINDENT_SAME=1 +val SC_WRAPINDENT_INDENT=2 + +# Sets how wrapped sublines are placed. Default is fixed. +set void SetWrapIndentMode=2472(int mode,) + +# Retrieve how wrapped sublines are placed. Default is fixed. +get int GetWrapIndentMode=2473(,) + +enu LineCache=SC_CACHE_ +val SC_CACHE_NONE=0 +val SC_CACHE_CARET=1 +val SC_CACHE_PAGE=2 +val SC_CACHE_DOCUMENT=3 + +# Sets the degree of caching of layout information. +set void SetLayoutCache=2272(int mode,) + +# Retrieve the degree of caching of layout information. +get int GetLayoutCache=2273(,) + +# Sets the document width assumed for scrolling. +set void SetScrollWidth=2274(int pixelWidth,) + +# Retrieve the document width assumed for scrolling. +get int GetScrollWidth=2275(,) + +# Sets whether the maximum width line displayed is used to set scroll width. +set void SetScrollWidthTracking=2516(bool tracking,) + +# Retrieve whether the scroll width tracks wide lines. +get bool GetScrollWidthTracking=2517(,) + +# Measure the pixel width of some text in a particular style. +# NUL terminated text argument. +# Does not handle tab or control characters. +fun int TextWidth=2276(int style, string text) + +# Sets the scroll range so that maximum scroll position has +# the last line at the bottom of the view (default). +# Setting this to false allows scrolling one page below the last line. +set void SetEndAtLastLine=2277(bool endAtLastLine,) + +# Retrieve whether the maximum scroll position has the last +# line at the bottom of the view. +get bool GetEndAtLastLine=2278(,) + +# Retrieve the height of a particular line of text in pixels. +fun int TextHeight=2279(int line,) + +# Show or hide the vertical scroll bar. +set void SetVScrollBar=2280(bool show,) + +# Is the vertical scroll bar visible? +get bool GetVScrollBar=2281(,) + +# Append a string to the end of the document without changing the selection. +fun void AppendText=2282(int length, string text) + +# Is drawing done in two phases with backgrounds drawn before faoregrounds? +get bool GetTwoPhaseDraw=2283(,) + +# In twoPhaseDraw mode, drawing is performed in two phases, first the background +# and then the foreground. This avoids chopping off characters that overlap the next run. +set void SetTwoPhaseDraw=2284(bool twoPhase,) + +# Control font anti-aliasing. + +enu FontQuality=SC_EFF_ +val SC_EFF_QUALITY_MASK=0xF +val SC_EFF_QUALITY_DEFAULT=0 +val SC_EFF_QUALITY_NON_ANTIALIASED=1 +val SC_EFF_QUALITY_ANTIALIASED=2 +val SC_EFF_QUALITY_LCD_OPTIMIZED=3 + +# Choose the quality level for text from the FontQuality enumeration. +set void SetFontQuality=2611(int fontQuality,) + +# Retrieve the quality level for text. +get int GetFontQuality=2612(,) + +# Scroll so that a display line is at the top of the display. +set void SetFirstVisibleLine=2613(int lineDisplay,) + +enu MultiPaste=SC_MULTIPASTE_ +val SC_MULTIPASTE_ONCE=0 +val SC_MULTIPASTE_EACH=1 + +# Change the effect of pasting when there are multiple selections. +set void SetMultiPaste=2614(int multiPaste,) + +# Retrieve the effect of pasting when there are multiple selections.. +get int GetMultiPaste=2615(,) + +# Retrieve the value of a tag from a regular expression search. +fun int GetTag=2616(int tagNumber, stringresult tagValue) + +# Make the target range start and end be the same as the selection range start and end. +fun void TargetFromSelection=2287(,) + +# Join the lines in the target. +fun void LinesJoin=2288(,) + +# Split the lines in the target into lines that are less wide than pixelWidth +# where possible. +fun void LinesSplit=2289(int pixelWidth,) + +# Set the colours used as a chequerboard pattern in the fold margin +fun void SetFoldMarginColour=2290(bool useSetting, colour back) +fun void SetFoldMarginHiColour=2291(bool useSetting, colour fore) + +## New messages go here + +## Start of key messages +# Move caret down one line. +fun void LineDown=2300(,) + +# Move caret down one line extending selection to new caret position. +fun void LineDownExtend=2301(,) + +# Move caret up one line. +fun void LineUp=2302(,) + +# Move caret up one line extending selection to new caret position. +fun void LineUpExtend=2303(,) + +# Move caret left one character. +fun void CharLeft=2304(,) + +# Move caret left one character extending selection to new caret position. +fun void CharLeftExtend=2305(,) + +# Move caret right one character. +fun void CharRight=2306(,) + +# Move caret right one character extending selection to new caret position. +fun void CharRightExtend=2307(,) + +# Move caret left one word. +fun void WordLeft=2308(,) + +# Move caret left one word extending selection to new caret position. +fun void WordLeftExtend=2309(,) + +# Move caret right one word. +fun void WordRight=2310(,) + +# Move caret right one word extending selection to new caret position. +fun void WordRightExtend=2311(,) + +# Move caret to first position on line. +fun void Home=2312(,) + +# Move caret to first position on line extending selection to new caret position. +fun void HomeExtend=2313(,) + +# Move caret to last position on line. +fun void LineEnd=2314(,) + +# Move caret to last position on line extending selection to new caret position. +fun void LineEndExtend=2315(,) + +# Move caret to first position in document. +fun void DocumentStart=2316(,) + +# Move caret to first position in document extending selection to new caret position. +fun void DocumentStartExtend=2317(,) + +# Move caret to last position in document. +fun void DocumentEnd=2318(,) + +# Move caret to last position in document extending selection to new caret position. +fun void DocumentEndExtend=2319(,) + +# Move caret one page up. +fun void PageUp=2320(,) + +# Move caret one page up extending selection to new caret position. +fun void PageUpExtend=2321(,) + +# Move caret one page down. +fun void PageDown=2322(,) + +# Move caret one page down extending selection to new caret position. +fun void PageDownExtend=2323(,) + +# Switch from insert to overtype mode or the reverse. +fun void EditToggleOvertype=2324(,) + +# Cancel any modes such as call tip or auto-completion list display. +fun void Cancel=2325(,) + +# Delete the selection or if no selection, the character before the caret. +fun void DeleteBack=2326(,) + +# If selection is empty or all on one line replace the selection with a tab character. +# If more than one line selected, indent the lines. +fun void Tab=2327(,) + +# Dedent the selected lines. +fun void BackTab=2328(,) + +# Insert a new line, may use a CRLF, CR or LF depending on EOL mode. +fun void NewLine=2329(,) + +# Insert a Form Feed character. +fun void FormFeed=2330(,) + +# Move caret to before first visible character on line. +# If already there move to first character on line. +fun void VCHome=2331(,) + +# Like VCHome but extending selection to new caret position. +fun void VCHomeExtend=2332(,) + +# Magnify the displayed text by increasing the sizes by 1 point. +fun void ZoomIn=2333(,) + +# Make the displayed text smaller by decreasing the sizes by 1 point. +fun void ZoomOut=2334(,) + +# Delete the word to the left of the caret. +fun void DelWordLeft=2335(,) + +# Delete the word to the right of the caret. +fun void DelWordRight=2336(,) + +# Delete the word to the right of the caret, but not the trailing non-word characters. +fun void DelWordRightEnd=2518(,) + +# Cut the line containing the caret. +fun void LineCut=2337(,) + +# Delete the line containing the caret. +fun void LineDelete=2338(,) + +# Switch the current line with the previous. +fun void LineTranspose=2339(,) + +# Duplicate the current line. +fun void LineDuplicate=2404(,) + +# Transform the selection to lower case. +fun void LowerCase=2340(,) + +# Transform the selection to upper case. +fun void UpperCase=2341(,) + +# Scroll the document down, keeping the caret visible. +fun void LineScrollDown=2342(,) + +# Scroll the document up, keeping the caret visible. +fun void LineScrollUp=2343(,) + +# Delete the selection or if no selection, the character before the caret. +# Will not delete the character before at the start of a line. +fun void DeleteBackNotLine=2344(,) + +# Move caret to first position on display line. +fun void HomeDisplay=2345(,) + +# Move caret to first position on display line extending selection to +# new caret position. +fun void HomeDisplayExtend=2346(,) + +# Move caret to last position on display line. +fun void LineEndDisplay=2347(,) + +# Move caret to last position on display line extending selection to new +# caret position. +fun void LineEndDisplayExtend=2348(,) + +# These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)? +# except they behave differently when word-wrap is enabled: +# They go first to the start / end of the display line, like (Home|LineEnd)Display +# The difference is that, the cursor is already at the point, it goes on to the start +# or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?. + +fun void HomeWrap=2349(,) +fun void HomeWrapExtend=2450(,) +fun void LineEndWrap=2451(,) +fun void LineEndWrapExtend=2452(,) +fun void VCHomeWrap=2453(,) +fun void VCHomeWrapExtend=2454(,) + +# Copy the line containing the caret. +fun void LineCopy=2455(,) + +# Move the caret inside current view if it's not there already. +fun void MoveCaretInsideView=2401(,) + +# How many characters are on a line, including end of line characters? +fun int LineLength=2350(int line,) + +# Highlight the characters at two positions. +fun void BraceHighlight=2351(position pos1, position pos2) + +# Highlight the character at a position indicating there is no matching brace. +fun void BraceBadLight=2352(position pos,) + +# Find the position of a matching brace or INVALID_POSITION if no match. +fun position BraceMatch=2353(position pos,) + +# Are the end of line characters visible? +get bool GetViewEOL=2355(,) + +# Make the end of line characters visible or invisible. +set void SetViewEOL=2356(bool visible,) + +# Retrieve a pointer to the document object. +get int GetDocPointer=2357(,) + +# Change the document object used. +set void SetDocPointer=2358(, int pointer) + +# Set which document modification events are sent to the container. +set void SetModEventMask=2359(int mask,) + +enu EdgeVisualStyle=EDGE_ +val EDGE_NONE=0 +val EDGE_LINE=1 +val EDGE_BACKGROUND=2 + +# Retrieve the column number which text should be kept within. +get int GetEdgeColumn=2360(,) + +# Set the column number of the edge. +# If text goes past the edge then it is highlighted. +set void SetEdgeColumn=2361(int column,) + +# Retrieve the edge highlight mode. +get int GetEdgeMode=2362(,) + +# The edge may be displayed by a line (EDGE_LINE) or by highlighting text that +# goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE). +set void SetEdgeMode=2363(int mode,) + +# Retrieve the colour used in edge indication. +get colour GetEdgeColour=2364(,) + +# Change the colour used in edge indication. +set void SetEdgeColour=2365(colour edgeColour,) + +# Sets the current caret position to be the search anchor. +fun void SearchAnchor=2366(,) + +# Find some text starting at the search anchor. +# Does not ensure the selection is visible. +fun int SearchNext=2367(int flags, string text) + +# Find some text starting at the search anchor and moving backwards. +# Does not ensure the selection is visible. +fun int SearchPrev=2368(int flags, string text) + +# Retrieves the number of lines completely visible. +get int LinesOnScreen=2370(,) + +# Set whether a pop up menu is displayed automatically when the user presses +# the wrong mouse button. +fun void UsePopUp=2371(bool allowPopUp,) + +# Is the selection rectangular? The alternative is the more common stream selection. +get bool SelectionIsRectangle=2372(,) + +# Set the zoom level. This number of points is added to the size of all fonts. +# It may be positive to magnify or negative to reduce. +set void SetZoom=2373(int zoom,) +# Retrieve the zoom level. +get int GetZoom=2374(,) + +# Create a new document object. +# Starts with reference count of 1 and not selected into editor. +fun int CreateDocument=2375(,) +# Extend life of document. +fun void AddRefDocument=2376(, int doc) +# Release a reference to the document, deleting document if it fades to black. +fun void ReleaseDocument=2377(, int doc) + +# Get which document modification events are sent to the container. +get int GetModEventMask=2378(,) + +# Change internal focus flag. +set void SetFocus=2380(bool focus,) +# Get internal focus flag. +get bool GetFocus=2381(,) + +enu Status=SC_STATUS_ +val SC_STATUS_OK=0 +val SC_STATUS_FAILURE=1 +val SC_STATUS_BADALLOC=2 + +# Change error status - 0 = OK. +set void SetStatus=2382(int statusCode,) +# Get error status. +get int GetStatus=2383(,) + +# Set whether the mouse is captured when its button is pressed. +set void SetMouseDownCaptures=2384(bool captures,) +# Get whether mouse gets captured. +get bool GetMouseDownCaptures=2385(,) + +enu CursorShape=SC_CURSOR +val SC_CURSORNORMAL=-1 +val SC_CURSORWAIT=4 +# Sets the cursor to one of the SC_CURSOR* values. +set void SetCursor=2386(int cursorType,) +# Get cursor type. +get int GetCursor=2387(,) + +# Change the way control characters are displayed: +# If symbol is < 32, keep the drawn way, else, use the given character. +set void SetControlCharSymbol=2388(int symbol,) +# Get the way control characters are displayed. +get int GetControlCharSymbol=2389(,) + +# Move to the previous change in capitalisation. +fun void WordPartLeft=2390(,) +# Move to the previous change in capitalisation extending selection +# to new caret position. +fun void WordPartLeftExtend=2391(,) +# Move to the change next in capitalisation. +fun void WordPartRight=2392(,) +# Move to the next change in capitalisation extending selection +# to new caret position. +fun void WordPartRightExtend=2393(,) + +# Constants for use with SetVisiblePolicy, similar to SetCaretPolicy. +val VISIBLE_SLOP=0x01 +val VISIBLE_STRICT=0x04 +# Set the way the display area is determined when a particular line +# is to be moved to by Find, FindNext, GotoLine, etc. +fun void SetVisiblePolicy=2394(int visiblePolicy, int visibleSlop) + +# Delete back from the current position to the start of the line. +fun void DelLineLeft=2395(,) + +# Delete forwards from the current position to the end of the line. +fun void DelLineRight=2396(,) + +# Get and Set the xOffset (ie, horizonal scroll position). +set void SetXOffset=2397(int newOffset,) +get int GetXOffset=2398(,) + +# Set the last x chosen value to be the caret x position. +fun void ChooseCaretX=2399(,) + +# Set the focus to this Scintilla widget. +fun void GrabFocus=2400(,) + +enu CaretPolicy=CARET_ +# Caret policy, used by SetXCaretPolicy and SetYCaretPolicy. +# If CARET_SLOP is set, we can define a slop value: caretSlop. +# This value defines an unwanted zone (UZ) where the caret is... unwanted. +# This zone is defined as a number of pixels near the vertical margins, +# and as a number of lines near the horizontal margins. +# By keeping the caret away from the edges, it is seen within its context, +# so it is likely that the identifier that the caret is on can be completely seen, +# and that the current line is seen with some of the lines following it which are +# often dependent on that line. +val CARET_SLOP=0x01 +# If CARET_STRICT is set, the policy is enforced... strictly. +# The caret is centred on the display if slop is not set, +# and cannot go in the UZ if slop is set. +val CARET_STRICT=0x04 +# If CARET_JUMPS is set, the display is moved more energetically +# so the caret can move in the same direction longer before the policy is applied again. +val CARET_JUMPS=0x10 +# If CARET_EVEN is not set, instead of having symmetrical UZs, +# the left and bottom UZs are extended up to right and top UZs respectively. +# This way, we favour the displaying of useful information: the begining of lines, +# where most code reside, and the lines after the caret, eg. the body of a function. +val CARET_EVEN=0x08 + +# Set the way the caret is kept visible when going sideway. +# The exclusion zone is given in pixels. +fun void SetXCaretPolicy=2402(int caretPolicy, int caretSlop) + +# Set the way the line the caret is on is kept visible. +# The exclusion zone is given in lines. +fun void SetYCaretPolicy=2403(int caretPolicy, int caretSlop) + +# Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE). +set void SetPrintWrapMode=2406(int mode,) + +# Is printing line wrapped? +get int GetPrintWrapMode=2407(,) + +# Set a fore colour for active hotspots. +set void SetHotspotActiveFore=2410(bool useSetting, colour fore) + +# Get the fore colour for active hotspots. +get colour GetHotspotActiveFore=2494(,) + +# Set a back colour for active hotspots. +set void SetHotspotActiveBack=2411(bool useSetting, colour back) + +# Get the back colour for active hotspots. +get colour GetHotspotActiveBack=2495(,) + +# Enable / Disable underlining active hotspots. +set void SetHotspotActiveUnderline=2412(bool underline,) + +# Get whether underlining for active hotspots. +get bool GetHotspotActiveUnderline=2496(,) + +# Limit hotspots to single line so hotspots on two lines don't merge. +set void SetHotspotSingleLine=2421(bool singleLine,) + +# Get the HotspotSingleLine property +get bool GetHotspotSingleLine=2497(,) + +# Move caret between paragraphs (delimited by empty lines). +fun void ParaDown=2413(,) +fun void ParaDownExtend=2414(,) +fun void ParaUp=2415(,) +fun void ParaUpExtend=2416(,) + +# Given a valid document position, return the previous position taking code +# page into account. Returns 0 if passed 0. +fun position PositionBefore=2417(position pos,) + +# Given a valid document position, return the next position taking code +# page into account. Maximum value returned is the last position in the document. +fun position PositionAfter=2418(position pos,) + +# Copy a range of text to the clipboard. Positions are clipped into the document. +fun void CopyRange=2419(position start, position end) + +# Copy argument text to the clipboard. +fun void CopyText=2420(int length, string text) + +enu SelectionMode=SC_SEL_ +val SC_SEL_STREAM=0 +val SC_SEL_RECTANGLE=1 +val SC_SEL_LINES=2 +val SC_SEL_THIN=3 + +# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or +# by lines (SC_SEL_LINES). +set void SetSelectionMode=2422(int mode,) + +# Get the mode of the current selection. +get int GetSelectionMode=2423(,) + +# Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line). +fun position GetLineSelStartPosition=2424(int line,) + +# Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line). +fun position GetLineSelEndPosition=2425(int line,) + +## RectExtended rectangular selection moves +# Move caret down one line, extending rectangular selection to new caret position. +fun void LineDownRectExtend=2426(,) + +# Move caret up one line, extending rectangular selection to new caret position. +fun void LineUpRectExtend=2427(,) + +# Move caret left one character, extending rectangular selection to new caret position. +fun void CharLeftRectExtend=2428(,) + +# Move caret right one character, extending rectangular selection to new caret position. +fun void CharRightRectExtend=2429(,) + +# Move caret to first position on line, extending rectangular selection to new caret position. +fun void HomeRectExtend=2430(,) + +# Move caret to before first visible character on line. +# If already there move to first character on line. +# In either case, extend rectangular selection to new caret position. +fun void VCHomeRectExtend=2431(,) + +# Move caret to last position on line, extending rectangular selection to new caret position. +fun void LineEndRectExtend=2432(,) + +# Move caret one page up, extending rectangular selection to new caret position. +fun void PageUpRectExtend=2433(,) + +# Move caret one page down, extending rectangular selection to new caret position. +fun void PageDownRectExtend=2434(,) + + +# Move caret to top of page, or one page up if already at top of page. +fun void StutteredPageUp=2435(,) + +# Move caret to top of page, or one page up if already at top of page, extending selection to new caret position. +fun void StutteredPageUpExtend=2436(,) + +# Move caret to bottom of page, or one page down if already at bottom of page. +fun void StutteredPageDown=2437(,) + +# Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position. +fun void StutteredPageDownExtend=2438(,) + + +# Move caret left one word, position cursor at end of word. +fun void WordLeftEnd=2439(,) + +# Move caret left one word, position cursor at end of word, extending selection to new caret position. +fun void WordLeftEndExtend=2440(,) + +# Move caret right one word, position cursor at end of word. +fun void WordRightEnd=2441(,) + +# Move caret right one word, position cursor at end of word, extending selection to new caret position. +fun void WordRightEndExtend=2442(,) + +# Set the set of characters making up whitespace for when moving or selecting by word. +# Should be called after SetWordChars. +set void SetWhitespaceChars=2443(, string characters) + +# Reset the set of characters for whitespace and word characters to the defaults. +fun void SetCharsDefault=2444(,) + +# Get currently selected item position in the auto-completion list +fun int AutoCGetCurrent=2445(,) + +# Get currently selected item text in the auto-completion list +# Returns the length of the item text +fun int AutoCGetCurrentText=2610(, stringresult s) + +# Enlarge the document to a particular size of text bytes. +fun void Allocate=2446(int bytes,) + +# Returns the target converted to UTF8. +# Return the length in bytes. +fun int TargetAsUTF8=2447(, stringresult s) + +# Set the length of the utf8 argument for calling EncodedFromUTF8. +# Set to -1 and the string will be measured to the first nul. +fun void SetLengthForEncode=2448(int bytes,) + +# Translates a UTF8 string into the document encoding. +# Return the length of the result in bytes. +# On error return 0. +fun int EncodedFromUTF8=2449(string utf8, stringresult encoded) + +# Find the position of a column on a line taking into account tabs and +# multi-byte characters. If beyond end of line, return line end position. +fun int FindColumn=2456(int line, int column) + +# Can the caret preferred x position only be changed by explicit movement commands? +get bool GetCaretSticky=2457(,) + +# Stop the caret preferred x position changing when the user types. +set void SetCaretSticky=2458(bool useCaretStickyBehaviour,) + +# Switch between sticky and non-sticky: meant to be bound to a key. +fun void ToggleCaretSticky=2459(,) + +# Enable/Disable convert-on-paste for line endings +set void SetPasteConvertEndings=2467(bool convert,) + +# Get convert-on-paste setting +get bool GetPasteConvertEndings=2468(,) + +# Duplicate the selection. If selection empty duplicate the line containing the caret. +fun void SelectionDuplicate=2469(,) + +val SC_ALPHA_TRANSPARENT=0 +val SC_ALPHA_OPAQUE=255 +val SC_ALPHA_NOALPHA=256 + +# Set background alpha of the caret line. +set void SetCaretLineBackAlpha=2470(int alpha,) + +# Get the background alpha of the caret line. +get int GetCaretLineBackAlpha=2471(,) + +enu CaretStyle=CARETSTYLE_ +val CARETSTYLE_INVISIBLE=0 +val CARETSTYLE_LINE=1 +val CARETSTYLE_BLOCK=2 + +# Set the style of the caret to be drawn. +set void SetCaretStyle=2512(int caretStyle,) + +# Returns the current style of the caret. +get int GetCaretStyle=2513(,) + +# Set the indicator used for IndicatorFillRange and IndicatorClearRange +set void SetIndicatorCurrent=2500(int indicator,) + +# Get the current indicator +get int GetIndicatorCurrent=2501(,) + +# Set the value used for IndicatorFillRange +set void SetIndicatorValue=2502(int value,) + +# Get the current indicator vaue +get int GetIndicatorValue=2503(,) + +# Turn a indicator on over a range. +fun void IndicatorFillRange=2504(int position, int fillLength) + +# Turn a indicator off over a range. +fun void IndicatorClearRange=2505(int position, int clearLength) + +# Are any indicators present at position? +fun int IndicatorAllOnFor=2506(int position,) + +# What value does a particular indicator have at at a position? +fun int IndicatorValueAt=2507(int indicator, int position) + +# Where does a particular indicator start? +fun int IndicatorStart=2508(int indicator, int position) + +# Where does a particular indicator end? +fun int IndicatorEnd=2509(int indicator, int position) + +# Set number of entries in position cache +set void SetPositionCache=2514(int size,) + +# How many entries are allocated to the position cache? +get int GetPositionCache=2515(,) + +# Copy the selection, if selection empty copy the line with the caret +fun void CopyAllowLine=2519(,) + +# Compact the document buffer and return a read-only pointer to the +# characters in the document. +get int GetCharacterPointer=2520(,) + +# Always interpret keyboard input as Unicode +set void SetKeysUnicode=2521(bool keysUnicode,) + +# Are keys always interpreted as Unicode? +get bool GetKeysUnicode=2522(,) + +# Set the alpha fill colour of the given indicator. +set void IndicSetAlpha=2523(int indicator, int alpha) + +# Get the alpha fill colour of the given indicator. +get int IndicGetAlpha=2524(int indicator,) + +# Set extra ascent for each line +set void SetExtraAscent=2525(int extraAscent,) + +# Get extra ascent for each line +get int GetExtraAscent=2526(,) + +# Set extra descent for each line +set void SetExtraDescent=2527(int extraDescent,) + +# Get extra descent for each line +get int GetExtraDescent=2528(,) + +# Which symbol was defined for markerNumber with MarkerDefine +fun int MarkerSymbolDefined=2529(int markerNumber,) + +# Set the text in the text margin for a line +set void MarginSetText=2530(int line, string text) + +# Get the text in the text margin for a line +get int MarginGetText=2531(int line, stringresult text) + +# Set the style number for the text margin for a line +set void MarginSetStyle=2532(int line, int style) + +# Get the style number for the text margin for a line +get int MarginGetStyle=2533(int line,) + +# Set the style in the text margin for a line +set void MarginSetStyles=2534(int line, string styles) + +# Get the styles in the text margin for a line +get int MarginGetStyles=2535(int line, stringresult styles) + +# Clear the margin text on all lines +fun void MarginTextClearAll=2536(,) + +# Get the start of the range of style numbers used for margin text +set void MarginSetStyleOffset=2537(int style,) + +# Get the start of the range of style numbers used for margin text +get int MarginGetStyleOffset=2538(,) + +# Set the annotation text for a line +set void AnnotationSetText=2540(int line, string text) + +# Get the annotation text for a line +get int AnnotationGetText=2541(int line, stringresult text) + +# Set the style number for the annotations for a line +set void AnnotationSetStyle=2542(int line, int style) + +# Get the style number for the annotations for a line +get int AnnotationGetStyle=2543(int line,) + +# Set the annotation styles for a line +set void AnnotationSetStyles=2544(int line, string styles) + +# Get the annotation styles for a line +get int AnnotationGetStyles=2545(int line, stringresult styles) + +# Get the number of annotation lines for a line +get int AnnotationGetLines=2546(int line,) + +# Clear the annotations from all lines +fun void AnnotationClearAll=2547(,) + +enu AnnotationVisible=ANNOTATION_ +val ANNOTATION_HIDDEN=0 +val ANNOTATION_STANDARD=1 +val ANNOTATION_BOXED=2 + +# Set the visibility for the annotations for a view +set void AnnotationSetVisible=2548(int visible,) + +# Get the visibility for the annotations for a view +get int AnnotationGetVisible=2549(,) + +# Get the start of the range of style numbers used for annotations +set void AnnotationSetStyleOffset=2550(int style,) + +# Get the start of the range of style numbers used for annotations +get int AnnotationGetStyleOffset=2551(,) + +val UNDO_MAY_COALESCE=1 + +# Add a container action to the undo stack +fun void AddUndoAction=2560(int token, int flags) + +# Find the position of a character from a point within the window. +fun position CharPositionFromPoint=2561(int x, int y) + +# Find the position of a character from a point within the window. +# Return INVALID_POSITION if not close to text. +fun position CharPositionFromPointClose=2562(int x, int y) + +# Set whether multiple selections can be made +set void SetMultipleSelection=2563(bool multipleSelection,) + +# Whether multiple selections can be made +get bool GetMultipleSelection=2564(,) + +# Set whether typing can be performed into multiple selections +set void SetAdditionalSelectionTyping=2565(bool additionalSelectionTyping,) + +# Whether typing can be performed into multiple selections +get bool GetAdditionalSelectionTyping=2566(,) + +# Set whether additional carets will blink +set void SetAdditionalCaretsBlink=2567(bool additionalCaretsBlink,) + +# Whether additional carets will blink +get bool GetAdditionalCaretsBlink=2568(,) + +# Set whether additional carets are visible +set void SetAdditionalCaretsVisible=2608(bool additionalCaretsBlink,) + +# Whether additional carets are visible +get bool GetAdditionalCaretsVisible=2609(,) + +# How many selections are there? +get int GetSelections=2570(,) + +# Clear selections to a single empty stream selection +fun void ClearSelections=2571(,) + +# Set a simple selection +fun int SetSelection=2572(int caret,int anchor) + +# Add a selection +fun int AddSelection=2573(int caret,int anchor) + +# Set the main selection +set void SetMainSelection=2574(int selection,) + +# Which selection is the main selection +get int GetMainSelection=2575(,) + +set void SetSelectionNCaret=2576(int selection, position pos) +get position GetSelectionNCaret=2577(int selection,) +set void SetSelectionNAnchor=2578(int selection, position posAnchor) +get position GetSelectionNAnchor=2579(int selection,) +set void SetSelectionNCaretVirtualSpace=2580(int selection, int space) +get int GetSelectionNCaretVirtualSpace=2581(int selection,) +set void SetSelectionNAnchorVirtualSpace=2582(int selection, int space) +get int GetSelectionNAnchorVirtualSpace=2583(int selection,) + +# Sets the position that starts the selection - this becomes the anchor. +set void SetSelectionNStart=2584(int selection, position pos) + +# Returns the position at the start of the selection. +get position GetSelectionNStart=2585(int selection,) + +# Sets the position that ends the selection - this becomes the currentPosition. +set void SetSelectionNEnd=2586(int selection, position pos,) + +# Returns the position at the end of the selection. +get position GetSelectionNEnd=2587(int selection,) + +set void SetRectangularSelectionCaret=2588(position pos,) +get position GetRectangularSelectionCaret=2589(,) +set void SetRectangularSelectionAnchor=2590(position posAnchor,) +get position GetRectangularSelectionAnchor=2591(,) +set void SetRectangularSelectionCaretVirtualSpace=2592(int space,) +get int GetRectangularSelectionCaretVirtualSpace=2593(,) +set void SetRectangularSelectionAnchorVirtualSpace=2594(int space,) +get int GetRectangularSelectionAnchorVirtualSpace=2595(,) + +enu VirtualSpace=SCVS_ +val SCVS_NONE=0 +val SCVS_RECTANGULARSELECTION=1 +val SCVS_USERACCESSIBLE=2 + +set void SetVirtualSpaceOptions=2596(int virtualSpaceOptions,) +get int GetVirtualSpaceOptions=2597(,) + +# On GTK+, allow selecting the modifier key to use for mouse-based +# rectangular selection. Often the window manager requires Alt+Mouse Drag +# for moving windows. +# Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER. + +set void SetRectangularSelectionModifier=2598(int modifier,) + +# Get the modifier key used for rectangular selection. +get int GetRectangularSelectionModifier=2599(,) + +# Set the foreground colour of additional selections. +# Must have previously called SetSelFore with non-zero first argument for this to have an effect. +set void SetAdditionalSelFore=2600(colour fore,) + +# Set the background colour of additional selections. +# Must have previously called SetSelBack with non-zero first argument for this to have an effect. +set void SetAdditionalSelBack=2601(colour back,) + +# Set the alpha of the selection. +set void SetAdditionalSelAlpha=2602(int alpha,) + +# Get the alpha of the selection. +get int GetAdditionalSelAlpha=2603(,) + +# Set the foreground colour of additional carets. +set void SetAdditionalCaretFore=2604(colour fore,) + +# Get the foreground colour of additional carets. +get colour GetAdditionalCaretFore=2605(,) + +# Set the main selection to the next selection. +fun void RotateSelection=2606(,) + +# Swap that caret and anchor of the main selection. +fun void SwapMainAnchorCaret=2607(,) + +# Start notifying the container of all key presses and commands. +fun void StartRecord=3001(,) + +# Stop notifying the container of all key presses and commands. +fun void StopRecord=3002(,) + +# Set the lexing language of the document. +set void SetLexer=4001(int lexer,) + +# Retrieve the lexing language of the document. +get int GetLexer=4002(,) + +# Colourise a segment of the document using the current lexing language. +fun void Colourise=4003(position start, position end) + +# Set up a value that may be used by a lexer for some optional feature. +set void SetProperty=4004(string key, string value) + +# Maximum value of keywordSet parameter of SetKeyWords. +val KEYWORDSET_MAX=8 + +# Set up the key words used by the lexer. +set void SetKeyWords=4005(int keywordSet, string keyWords) + +# Set the lexing language of the document based on string name. +set void SetLexerLanguage=4006(, string language) + +# Load a lexer library (dll / so). +fun void LoadLexerLibrary=4007(, string path) + +# Retrieve a "property" value previously set with SetProperty. +fun int GetProperty=4008(string key, stringresult buf) + +# Retrieve a "property" value previously set with SetProperty, +# with "$()" variable replacement on returned buffer. +fun int GetPropertyExpanded=4009(string key, stringresult buf) + +# Retrieve a "property" value previously set with SetProperty, +# interpreted as an int AFTER any "$()" variable replacement. +get int GetPropertyInt=4010(string key,) + +# Retrieve the number of bits the current lexer needs for styling. +get int GetStyleBitsNeeded=4011(,) + +# Retrieve the name of the lexer. +# Return the length of the text. +get int GetLexerLanguage=4012(, stringresult text) + +# Notifications +# Type of modification and the action which caused the modification. +# These are defined as a bit mask to make it easy to specify which notifications are wanted. +# One bit is set from each of SC_MOD_* and SC_PERFORMED_*. +enu ModificationFlags=SC_MOD_ SC_PERFORMED_ SC_LAST +val SC_MOD_INSERTTEXT=0x1 +val SC_MOD_DELETETEXT=0x2 +val SC_MOD_CHANGESTYLE=0x4 +val SC_MOD_CHANGEFOLD=0x8 +val SC_PERFORMED_USER=0x10 +val SC_PERFORMED_UNDO=0x20 +val SC_PERFORMED_REDO=0x40 +val SC_MULTISTEPUNDOREDO=0x80 +val SC_LASTSTEPINUNDOREDO=0x100 +val SC_MOD_CHANGEMARKER=0x200 +val SC_MOD_BEFOREINSERT=0x400 +val SC_MOD_BEFOREDELETE=0x800 +val SC_MULTILINEUNDOREDO=0x1000 +val SC_STARTACTION=0x2000 +val SC_MOD_CHANGEINDICATOR=0x4000 +val SC_MOD_CHANGELINESTATE=0x8000 +val SC_MOD_CHANGEMARGIN=0x10000 +val SC_MOD_CHANGEANNOTATION=0x20000 +val SC_MOD_CONTAINER=0x40000 +val SC_MODEVENTMASKALL=0x7FFFF + +# For compatibility, these go through the COMMAND notification rather than NOTIFY +# and should have had exactly the same values as the EN_* constants. +# Unfortunately the SETFOCUS and KILLFOCUS are flipped over from EN_* +# As clients depend on these constants, this will not be changed. +val SCEN_CHANGE=768 +val SCEN_SETFOCUS=512 +val SCEN_KILLFOCUS=256 + +# Symbolic key codes and modifier flags. +# ASCII and other printable characters below 256. +# Extended keys above 300. + +enu Keys=SCK_ +val SCK_DOWN=300 +val SCK_UP=301 +val SCK_LEFT=302 +val SCK_RIGHT=303 +val SCK_HOME=304 +val SCK_END=305 +val SCK_PRIOR=306 +val SCK_NEXT=307 +val SCK_DELETE=308 +val SCK_INSERT=309 +val SCK_ESCAPE=7 +val SCK_BACK=8 +val SCK_TAB=9 +val SCK_RETURN=13 +val SCK_ADD=310 +val SCK_SUBTRACT=311 +val SCK_DIVIDE=312 +val SCK_WIN=313 +val SCK_RWIN=314 +val SCK_MENU=315 + +enu KeyMod=SCMOD_ +val SCMOD_NORM=0 +val SCMOD_SHIFT=1 +val SCMOD_CTRL=2 +val SCMOD_ALT=4 +val SCMOD_SUPER=8 + +################################################ +# For SciLexer.h +enu Lexer=SCLEX_ +val SCLEX_CONTAINER=0 +val SCLEX_NULL=1 +val SCLEX_PYTHON=2 +val SCLEX_CPP=3 +val SCLEX_HTML=4 +val SCLEX_XML=5 +val SCLEX_PERL=6 +val SCLEX_SQL=7 +val SCLEX_VB=8 +val SCLEX_PROPERTIES=9 +val SCLEX_ERRORLIST=10 +val SCLEX_MAKEFILE=11 +val SCLEX_BATCH=12 +val SCLEX_XCODE=13 +val SCLEX_LATEX=14 +val SCLEX_LUA=15 +val SCLEX_DIFF=16 +val SCLEX_CONF=17 +val SCLEX_PASCAL=18 +val SCLEX_AVE=19 +val SCLEX_ADA=20 +val SCLEX_LISP=21 +val SCLEX_RUBY=22 +val SCLEX_EIFFEL=23 +val SCLEX_EIFFELKW=24 +val SCLEX_TCL=25 +val SCLEX_NNCRONTAB=26 +val SCLEX_BULLANT=27 +val SCLEX_VBSCRIPT=28 +val SCLEX_BAAN=31 +val SCLEX_MATLAB=32 +val SCLEX_SCRIPTOL=33 +val SCLEX_ASM=34 +val SCLEX_CPPNOCASE=35 +val SCLEX_FORTRAN=36 +val SCLEX_F77=37 +val SCLEX_CSS=38 +val SCLEX_POV=39 +val SCLEX_LOUT=40 +val SCLEX_ESCRIPT=41 +val SCLEX_PS=42 +val SCLEX_NSIS=43 +val SCLEX_MMIXAL=44 +val SCLEX_CLW=45 +val SCLEX_CLWNOCASE=46 +val SCLEX_LOT=47 +val SCLEX_YAML=48 +val SCLEX_TEX=49 +val SCLEX_METAPOST=50 +val SCLEX_POWERBASIC=51 +val SCLEX_FORTH=52 +val SCLEX_ERLANG=53 +val SCLEX_OCTAVE=54 +val SCLEX_MSSQL=55 +val SCLEX_VERILOG=56 +val SCLEX_KIX=57 +val SCLEX_GUI4CLI=58 +val SCLEX_SPECMAN=59 +val SCLEX_AU3=60 +val SCLEX_APDL=61 +val SCLEX_BASH=62 +val SCLEX_ASN1=63 +val SCLEX_VHDL=64 +val SCLEX_CAML=65 +val SCLEX_BLITZBASIC=66 +val SCLEX_PUREBASIC=67 +val SCLEX_HASKELL=68 +val SCLEX_PHPSCRIPT=69 +val SCLEX_TADS3=70 +val SCLEX_REBOL=71 +val SCLEX_SMALLTALK=72 +val SCLEX_FLAGSHIP=73 +val SCLEX_CSOUND=74 +val SCLEX_FREEBASIC=75 +val SCLEX_INNOSETUP=76 +val SCLEX_OPAL=77 +val SCLEX_SPICE=78 +val SCLEX_D=79 +val SCLEX_CMAKE=80 +val SCLEX_GAP=81 +val SCLEX_PLM=82 +val SCLEX_PROGRESS=83 +val SCLEX_ABAQUS=84 +val SCLEX_ASYMPTOTE=85 +val SCLEX_R=86 +val SCLEX_MAGIK=87 +val SCLEX_POWERSHELL=88 +val SCLEX_MYSQL=89 +val SCLEX_PO=90 +val SCLEX_TAL=91 +val SCLEX_COBOL=92 +val SCLEX_TACL=93 +val SCLEX_SORCUS=94 +val SCLEX_POWERPRO=95 +val SCLEX_NIMROD=96 +val SCLEX_SML=97 +val SCLEX_MARKDOWN=98 + +# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a +# value assigned in sequence from SCLEX_AUTOMATIC+1. +val SCLEX_AUTOMATIC=1000 +# Lexical states for SCLEX_PYTHON +lex Python=SCLEX_PYTHON SCE_P_ +lex Nimrod=SCLEX_NIMROD SCE_P_ +val SCE_P_DEFAULT=0 +val SCE_P_COMMENTLINE=1 +val SCE_P_NUMBER=2 +val SCE_P_STRING=3 +val SCE_P_CHARACTER=4 +val SCE_P_WORD=5 +val SCE_P_TRIPLE=6 +val SCE_P_TRIPLEDOUBLE=7 +val SCE_P_CLASSNAME=8 +val SCE_P_DEFNAME=9 +val SCE_P_OPERATOR=10 +val SCE_P_IDENTIFIER=11 +val SCE_P_COMMENTBLOCK=12 +val SCE_P_STRINGEOL=13 +val SCE_P_WORD2=14 +val SCE_P_DECORATOR=15 +# Lexical states for SCLEX_CPP +lex Cpp=SCLEX_CPP SCE_C_ +lex BullAnt=SCLEX_BULLANT SCE_C_ +val SCE_C_DEFAULT=0 +val SCE_C_COMMENT=1 +val SCE_C_COMMENTLINE=2 +val SCE_C_COMMENTDOC=3 +val SCE_C_NUMBER=4 +val SCE_C_WORD=5 +val SCE_C_STRING=6 +val SCE_C_CHARACTER=7 +val SCE_C_UUID=8 +val SCE_C_PREPROCESSOR=9 +val SCE_C_OPERATOR=10 +val SCE_C_IDENTIFIER=11 +val SCE_C_STRINGEOL=12 +val SCE_C_VERBATIM=13 +val SCE_C_REGEX=14 +val SCE_C_COMMENTLINEDOC=15 +val SCE_C_WORD2=16 +val SCE_C_COMMENTDOCKEYWORD=17 +val SCE_C_COMMENTDOCKEYWORDERROR=18 +val SCE_C_GLOBALCLASS=19 +# Lexical states for SCLEX_D +lex D=SCLEX_D SCE_D_ +val SCE_D_DEFAULT=0 +val SCE_D_COMMENT=1 +val SCE_D_COMMENTLINE=2 +val SCE_D_COMMENTDOC=3 +val SCE_D_COMMENTNESTED=4 +val SCE_D_NUMBER=5 +val SCE_D_WORD=6 +val SCE_D_WORD2=7 +val SCE_D_WORD3=8 +val SCE_D_TYPEDEF=9 +val SCE_D_STRING=10 +val SCE_D_STRINGEOL=11 +val SCE_D_CHARACTER=12 +val SCE_D_OPERATOR=13 +val SCE_D_IDENTIFIER=14 +val SCE_D_COMMENTLINEDOC=15 +val SCE_D_COMMENTDOCKEYWORD=16 +val SCE_D_COMMENTDOCKEYWORDERROR=17 +val SCE_D_STRINGB=18 +val SCE_D_STRINGR=19 +val SCE_D_WORD5=20 +val SCE_D_WORD6=21 +val SCE_D_WORD7=22 +# Lexical states for SCLEX_TCL +lex TCL=SCLEX_TCL SCE_TCL_ +val SCE_TCL_DEFAULT=0 +val SCE_TCL_COMMENT=1 +val SCE_TCL_COMMENTLINE=2 +val SCE_TCL_NUMBER=3 +val SCE_TCL_WORD_IN_QUOTE=4 +val SCE_TCL_IN_QUOTE=5 +val SCE_TCL_OPERATOR=6 +val SCE_TCL_IDENTIFIER=7 +val SCE_TCL_SUBSTITUTION=8 +val SCE_TCL_SUB_BRACE=9 +val SCE_TCL_MODIFIER=10 +val SCE_TCL_EXPAND=11 +val SCE_TCL_WORD=12 +val SCE_TCL_WORD2=13 +val SCE_TCL_WORD3=14 +val SCE_TCL_WORD4=15 +val SCE_TCL_WORD5=16 +val SCE_TCL_WORD6=17 +val SCE_TCL_WORD7=18 +val SCE_TCL_WORD8=19 +val SCE_TCL_COMMENT_BOX=20 +val SCE_TCL_BLOCK_COMMENT=21 +# Lexical states for SCLEX_HTML, SCLEX_XML +lex HTML=SCLEX_HTML SCE_H +lex XML=SCLEX_XML SCE_H +lex ASP=SCLEX_ASP SCE_H +lex PHP=SCLEX_PHP SCE_H +val SCE_H_DEFAULT=0 +val SCE_H_TAG=1 +val SCE_H_TAGUNKNOWN=2 +val SCE_H_ATTRIBUTE=3 +val SCE_H_ATTRIBUTEUNKNOWN=4 +val SCE_H_NUMBER=5 +val SCE_H_DOUBLESTRING=6 +val SCE_H_SINGLESTRING=7 +val SCE_H_OTHER=8 +val SCE_H_COMMENT=9 +val SCE_H_ENTITY=10 +# XML and ASP +val SCE_H_TAGEND=11 +val SCE_H_XMLSTART=12 +val SCE_H_XMLEND=13 +val SCE_H_SCRIPT=14 +val SCE_H_ASP=15 +val SCE_H_ASPAT=16 +val SCE_H_CDATA=17 +val SCE_H_QUESTION=18 +# More HTML +val SCE_H_VALUE=19 +# X-Code +val SCE_H_XCCOMMENT=20 +# SGML +val SCE_H_SGML_DEFAULT=21 +val SCE_H_SGML_COMMAND=22 +val SCE_H_SGML_1ST_PARAM=23 +val SCE_H_SGML_DOUBLESTRING=24 +val SCE_H_SGML_SIMPLESTRING=25 +val SCE_H_SGML_ERROR=26 +val SCE_H_SGML_SPECIAL=27 +val SCE_H_SGML_ENTITY=28 +val SCE_H_SGML_COMMENT=29 +val SCE_H_SGML_1ST_PARAM_COMMENT=30 +val SCE_H_SGML_BLOCK_DEFAULT=31 +# Embedded Javascript +val SCE_HJ_START=40 +val SCE_HJ_DEFAULT=41 +val SCE_HJ_COMMENT=42 +val SCE_HJ_COMMENTLINE=43 +val SCE_HJ_COMMENTDOC=44 +val SCE_HJ_NUMBER=45 +val SCE_HJ_WORD=46 +val SCE_HJ_KEYWORD=47 +val SCE_HJ_DOUBLESTRING=48 +val SCE_HJ_SINGLESTRING=49 +val SCE_HJ_SYMBOLS=50 +val SCE_HJ_STRINGEOL=51 +val SCE_HJ_REGEX=52 +# ASP Javascript +val SCE_HJA_START=55 +val SCE_HJA_DEFAULT=56 +val SCE_HJA_COMMENT=57 +val SCE_HJA_COMMENTLINE=58 +val SCE_HJA_COMMENTDOC=59 +val SCE_HJA_NUMBER=60 +val SCE_HJA_WORD=61 +val SCE_HJA_KEYWORD=62 +val SCE_HJA_DOUBLESTRING=63 +val SCE_HJA_SINGLESTRING=64 +val SCE_HJA_SYMBOLS=65 +val SCE_HJA_STRINGEOL=66 +val SCE_HJA_REGEX=67 +# Embedded VBScript +val SCE_HB_START=70 +val SCE_HB_DEFAULT=71 +val SCE_HB_COMMENTLINE=72 +val SCE_HB_NUMBER=73 +val SCE_HB_WORD=74 +val SCE_HB_STRING=75 +val SCE_HB_IDENTIFIER=76 +val SCE_HB_STRINGEOL=77 +# ASP VBScript +val SCE_HBA_START=80 +val SCE_HBA_DEFAULT=81 +val SCE_HBA_COMMENTLINE=82 +val SCE_HBA_NUMBER=83 +val SCE_HBA_WORD=84 +val SCE_HBA_STRING=85 +val SCE_HBA_IDENTIFIER=86 +val SCE_HBA_STRINGEOL=87 +# Embedded Python +val SCE_HP_START=90 +val SCE_HP_DEFAULT=91 +val SCE_HP_COMMENTLINE=92 +val SCE_HP_NUMBER=93 +val SCE_HP_STRING=94 +val SCE_HP_CHARACTER=95 +val SCE_HP_WORD=96 +val SCE_HP_TRIPLE=97 +val SCE_HP_TRIPLEDOUBLE=98 +val SCE_HP_CLASSNAME=99 +val SCE_HP_DEFNAME=100 +val SCE_HP_OPERATOR=101 +val SCE_HP_IDENTIFIER=102 +# PHP +val SCE_HPHP_COMPLEX_VARIABLE=104 +# ASP Python +val SCE_HPA_START=105 +val SCE_HPA_DEFAULT=106 +val SCE_HPA_COMMENTLINE=107 +val SCE_HPA_NUMBER=108 +val SCE_HPA_STRING=109 +val SCE_HPA_CHARACTER=110 +val SCE_HPA_WORD=111 +val SCE_HPA_TRIPLE=112 +val SCE_HPA_TRIPLEDOUBLE=113 +val SCE_HPA_CLASSNAME=114 +val SCE_HPA_DEFNAME=115 +val SCE_HPA_OPERATOR=116 +val SCE_HPA_IDENTIFIER=117 +# PHP +val SCE_HPHP_DEFAULT=118 +val SCE_HPHP_HSTRING=119 +val SCE_HPHP_SIMPLESTRING=120 +val SCE_HPHP_WORD=121 +val SCE_HPHP_NUMBER=122 +val SCE_HPHP_VARIABLE=123 +val SCE_HPHP_COMMENT=124 +val SCE_HPHP_COMMENTLINE=125 +val SCE_HPHP_HSTRING_VARIABLE=126 +val SCE_HPHP_OPERATOR=127 +# Lexical states for SCLEX_PERL +lex Perl=SCLEX_PERL SCE_PL_ +val SCE_PL_DEFAULT=0 +val SCE_PL_ERROR=1 +val SCE_PL_COMMENTLINE=2 +val SCE_PL_POD=3 +val SCE_PL_NUMBER=4 +val SCE_PL_WORD=5 +val SCE_PL_STRING=6 +val SCE_PL_CHARACTER=7 +val SCE_PL_PUNCTUATION=8 +val SCE_PL_PREPROCESSOR=9 +val SCE_PL_OPERATOR=10 +val SCE_PL_IDENTIFIER=11 +val SCE_PL_SCALAR=12 +val SCE_PL_ARRAY=13 +val SCE_PL_HASH=14 +val SCE_PL_SYMBOLTABLE=15 +val SCE_PL_VARIABLE_INDEXER=16 +val SCE_PL_REGEX=17 +val SCE_PL_REGSUBST=18 +val SCE_PL_LONGQUOTE=19 +val SCE_PL_BACKTICKS=20 +val SCE_PL_DATASECTION=21 +val SCE_PL_HERE_DELIM=22 +val SCE_PL_HERE_Q=23 +val SCE_PL_HERE_QQ=24 +val SCE_PL_HERE_QX=25 +val SCE_PL_STRING_Q=26 +val SCE_PL_STRING_QQ=27 +val SCE_PL_STRING_QX=28 +val SCE_PL_STRING_QR=29 +val SCE_PL_STRING_QW=30 +val SCE_PL_POD_VERB=31 +val SCE_PL_SUB_PROTOTYPE=40 +val SCE_PL_FORMAT_IDENT=41 +val SCE_PL_FORMAT=42 +# Lexical states for SCLEX_RUBY +lex Ruby=SCLEX_RUBY SCE_RB_ +val SCE_RB_DEFAULT=0 +val SCE_RB_ERROR=1 +val SCE_RB_COMMENTLINE=2 +val SCE_RB_POD=3 +val SCE_RB_NUMBER=4 +val SCE_RB_WORD=5 +val SCE_RB_STRING=6 +val SCE_RB_CHARACTER=7 +val SCE_RB_CLASSNAME=8 +val SCE_RB_DEFNAME=9 +val SCE_RB_OPERATOR=10 +val SCE_RB_IDENTIFIER=11 +val SCE_RB_REGEX=12 +val SCE_RB_GLOBAL=13 +val SCE_RB_SYMBOL=14 +val SCE_RB_MODULE_NAME=15 +val SCE_RB_INSTANCE_VAR=16 +val SCE_RB_CLASS_VAR=17 +val SCE_RB_BACKTICKS=18 +val SCE_RB_DATASECTION=19 +val SCE_RB_HERE_DELIM=20 +val SCE_RB_HERE_Q=21 +val SCE_RB_HERE_QQ=22 +val SCE_RB_HERE_QX=23 +val SCE_RB_STRING_Q=24 +val SCE_RB_STRING_QQ=25 +val SCE_RB_STRING_QX=26 +val SCE_RB_STRING_QR=27 +val SCE_RB_STRING_QW=28 +val SCE_RB_WORD_DEMOTED=29 +val SCE_RB_STDIN=30 +val SCE_RB_STDOUT=31 +val SCE_RB_STDERR=40 +val SCE_RB_UPPER_BOUND=41 +# Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC +lex VB=SCLEX_VB SCE_B_ +lex VBScript=SCLEX_VBSCRIPT SCE_B_ +lex PowerBasic=SCLEX_POWERBASIC SCE_B_ +val SCE_B_DEFAULT=0 +val SCE_B_COMMENT=1 +val SCE_B_NUMBER=2 +val SCE_B_KEYWORD=3 +val SCE_B_STRING=4 +val SCE_B_PREPROCESSOR=5 +val SCE_B_OPERATOR=6 +val SCE_B_IDENTIFIER=7 +val SCE_B_DATE=8 +val SCE_B_STRINGEOL=9 +val SCE_B_KEYWORD2=10 +val SCE_B_KEYWORD3=11 +val SCE_B_KEYWORD4=12 +val SCE_B_CONSTANT=13 +val SCE_B_ASM=14 +val SCE_B_LABEL=15 +val SCE_B_ERROR=16 +val SCE_B_HEXNUMBER=17 +val SCE_B_BINNUMBER=18 +# Lexical states for SCLEX_PROPERTIES +lex Properties=SCLEX_PROPERTIES SCE_PROPS_ +val SCE_PROPS_DEFAULT=0 +val SCE_PROPS_COMMENT=1 +val SCE_PROPS_SECTION=2 +val SCE_PROPS_ASSIGNMENT=3 +val SCE_PROPS_DEFVAL=4 +val SCE_PROPS_KEY=5 +# Lexical states for SCLEX_LATEX +lex LaTeX=SCLEX_LATEX SCE_L_ +val SCE_L_DEFAULT=0 +val SCE_L_COMMAND=1 +val SCE_L_TAG=2 +val SCE_L_MATH=3 +val SCE_L_COMMENT=4 +# Lexical states for SCLEX_LUA +lex Lua=SCLEX_LUA SCE_LUA_ +val SCE_LUA_DEFAULT=0 +val SCE_LUA_COMMENT=1 +val SCE_LUA_COMMENTLINE=2 +val SCE_LUA_COMMENTDOC=3 +val SCE_LUA_NUMBER=4 +val SCE_LUA_WORD=5 +val SCE_LUA_STRING=6 +val SCE_LUA_CHARACTER=7 +val SCE_LUA_LITERALSTRING=8 +val SCE_LUA_PREPROCESSOR=9 +val SCE_LUA_OPERATOR=10 +val SCE_LUA_IDENTIFIER=11 +val SCE_LUA_STRINGEOL=12 +val SCE_LUA_WORD2=13 +val SCE_LUA_WORD3=14 +val SCE_LUA_WORD4=15 +val SCE_LUA_WORD5=16 +val SCE_LUA_WORD6=17 +val SCE_LUA_WORD7=18 +val SCE_LUA_WORD8=19 +# Lexical states for SCLEX_ERRORLIST +lex ErrorList=SCLEX_ERRORLIST SCE_ERR_ +val SCE_ERR_DEFAULT=0 +val SCE_ERR_PYTHON=1 +val SCE_ERR_GCC=2 +val SCE_ERR_MS=3 +val SCE_ERR_CMD=4 +val SCE_ERR_BORLAND=5 +val SCE_ERR_PERL=6 +val SCE_ERR_NET=7 +val SCE_ERR_LUA=8 +val SCE_ERR_CTAG=9 +val SCE_ERR_DIFF_CHANGED=10 +val SCE_ERR_DIFF_ADDITION=11 +val SCE_ERR_DIFF_DELETION=12 +val SCE_ERR_DIFF_MESSAGE=13 +val SCE_ERR_PHP=14 +val SCE_ERR_ELF=15 +val SCE_ERR_IFC=16 +val SCE_ERR_IFORT=17 +val SCE_ERR_ABSF=18 +val SCE_ERR_TIDY=19 +val SCE_ERR_JAVA_STACK=20 +val SCE_ERR_VALUE=21 +# Lexical states for SCLEX_BATCH +lex Batch=SCLEX_BATCH SCE_BAT_ +val SCE_BAT_DEFAULT=0 +val SCE_BAT_COMMENT=1 +val SCE_BAT_WORD=2 +val SCE_BAT_LABEL=3 +val SCE_BAT_HIDE=4 +val SCE_BAT_COMMAND=5 +val SCE_BAT_IDENTIFIER=6 +val SCE_BAT_OPERATOR=7 +# Lexical states for SCLEX_MAKEFILE +lex MakeFile=SCLEX_MAKEFILE SCE_MAKE_ +val SCE_MAKE_DEFAULT=0 +val SCE_MAKE_COMMENT=1 +val SCE_MAKE_PREPROCESSOR=2 +val SCE_MAKE_IDENTIFIER=3 +val SCE_MAKE_OPERATOR=4 +val SCE_MAKE_TARGET=5 +val SCE_MAKE_IDEOL=9 +# Lexical states for SCLEX_DIFF +lex Diff=SCLEX_DIFF SCE_DIFF_ +val SCE_DIFF_DEFAULT=0 +val SCE_DIFF_COMMENT=1 +val SCE_DIFF_COMMAND=2 +val SCE_DIFF_HEADER=3 +val SCE_DIFF_POSITION=4 +val SCE_DIFF_DELETED=5 +val SCE_DIFF_ADDED=6 +val SCE_DIFF_CHANGED=7 +# Lexical states for SCLEX_CONF (Apache Configuration Files Lexer) +lex Conf=SCLEX_CONF SCE_CONF_ +val SCE_CONF_DEFAULT=0 +val SCE_CONF_COMMENT=1 +val SCE_CONF_NUMBER=2 +val SCE_CONF_IDENTIFIER=3 +val SCE_CONF_EXTENSION=4 +val SCE_CONF_PARAMETER=5 +val SCE_CONF_STRING=6 +val SCE_CONF_OPERATOR=7 +val SCE_CONF_IP=8 +val SCE_CONF_DIRECTIVE=9 +# Lexical states for SCLEX_AVE, Avenue +lex Avenue=SCLEX_AVE SCE_AVE_ +val SCE_AVE_DEFAULT=0 +val SCE_AVE_COMMENT=1 +val SCE_AVE_NUMBER=2 +val SCE_AVE_WORD=3 +val SCE_AVE_STRING=6 +val SCE_AVE_ENUM=7 +val SCE_AVE_STRINGEOL=8 +val SCE_AVE_IDENTIFIER=9 +val SCE_AVE_OPERATOR=10 +val SCE_AVE_WORD1=11 +val SCE_AVE_WORD2=12 +val SCE_AVE_WORD3=13 +val SCE_AVE_WORD4=14 +val SCE_AVE_WORD5=15 +val SCE_AVE_WORD6=16 +# Lexical states for SCLEX_ADA +lex Ada=SCLEX_ADA SCE_ADA_ +val SCE_ADA_DEFAULT=0 +val SCE_ADA_WORD=1 +val SCE_ADA_IDENTIFIER=2 +val SCE_ADA_NUMBER=3 +val SCE_ADA_DELIMITER=4 +val SCE_ADA_CHARACTER=5 +val SCE_ADA_CHARACTEREOL=6 +val SCE_ADA_STRING=7 +val SCE_ADA_STRINGEOL=8 +val SCE_ADA_LABEL=9 +val SCE_ADA_COMMENTLINE=10 +val SCE_ADA_ILLEGAL=11 +# Lexical states for SCLEX_BAAN +lex Baan=SCLEX_BAAN SCE_BAAN_ +val SCE_BAAN_DEFAULT=0 +val SCE_BAAN_COMMENT=1 +val SCE_BAAN_COMMENTDOC=2 +val SCE_BAAN_NUMBER=3 +val SCE_BAAN_WORD=4 +val SCE_BAAN_STRING=5 +val SCE_BAAN_PREPROCESSOR=6 +val SCE_BAAN_OPERATOR=7 +val SCE_BAAN_IDENTIFIER=8 +val SCE_BAAN_STRINGEOL=9 +val SCE_BAAN_WORD2=10 +# Lexical states for SCLEX_LISP +lex Lisp=SCLEX_LISP SCE_LISP_ +val SCE_LISP_DEFAULT=0 +val SCE_LISP_COMMENT=1 +val SCE_LISP_NUMBER=2 +val SCE_LISP_KEYWORD=3 +val SCE_LISP_KEYWORD_KW=4 +val SCE_LISP_SYMBOL=5 +val SCE_LISP_STRING=6 +val SCE_LISP_STRINGEOL=8 +val SCE_LISP_IDENTIFIER=9 +val SCE_LISP_OPERATOR=10 +val SCE_LISP_SPECIAL=11 +val SCE_LISP_MULTI_COMMENT=12 +# Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW +lex Eiffel=SCLEX_EIFFEL SCE_EIFFEL_ +lex EiffelKW=SCLEX_EIFFELKW SCE_EIFFEL_ +val SCE_EIFFEL_DEFAULT=0 +val SCE_EIFFEL_COMMENTLINE=1 +val SCE_EIFFEL_NUMBER=2 +val SCE_EIFFEL_WORD=3 +val SCE_EIFFEL_STRING=4 +val SCE_EIFFEL_CHARACTER=5 +val SCE_EIFFEL_OPERATOR=6 +val SCE_EIFFEL_IDENTIFIER=7 +val SCE_EIFFEL_STRINGEOL=8 +# Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer) +lex NNCronTab=SCLEX_NNCRONTAB SCE_NNCRONTAB_ +val SCE_NNCRONTAB_DEFAULT=0 +val SCE_NNCRONTAB_COMMENT=1 +val SCE_NNCRONTAB_TASK=2 +val SCE_NNCRONTAB_SECTION=3 +val SCE_NNCRONTAB_KEYWORD=4 +val SCE_NNCRONTAB_MODIFIER=5 +val SCE_NNCRONTAB_ASTERISK=6 +val SCE_NNCRONTAB_NUMBER=7 +val SCE_NNCRONTAB_STRING=8 +val SCE_NNCRONTAB_ENVIRONMENT=9 +val SCE_NNCRONTAB_IDENTIFIER=10 +# Lexical states for SCLEX_FORTH (Forth Lexer) +lex Forth=SCLEX_FORTH SCE_FORTH_ +val SCE_FORTH_DEFAULT=0 +val SCE_FORTH_COMMENT=1 +val SCE_FORTH_COMMENT_ML=2 +val SCE_FORTH_IDENTIFIER=3 +val SCE_FORTH_CONTROL=4 +val SCE_FORTH_KEYWORD=5 +val SCE_FORTH_DEFWORD=6 +val SCE_FORTH_PREWORD1=7 +val SCE_FORTH_PREWORD2=8 +val SCE_FORTH_NUMBER=9 +val SCE_FORTH_STRING=10 +val SCE_FORTH_LOCALE=11 +# Lexical states for SCLEX_MATLAB +lex MatLab=SCLEX_MATLAB SCE_MATLAB_ +val SCE_MATLAB_DEFAULT=0 +val SCE_MATLAB_COMMENT=1 +val SCE_MATLAB_COMMAND=2 +val SCE_MATLAB_NUMBER=3 +val SCE_MATLAB_KEYWORD=4 +# single quoted string +val SCE_MATLAB_STRING=5 +val SCE_MATLAB_OPERATOR=6 +val SCE_MATLAB_IDENTIFIER=7 +val SCE_MATLAB_DOUBLEQUOTESTRING=8 +# Lexical states for SCLEX_SCRIPTOL +lex Sol=SCLEX_SCRIPTOL SCE_SCRIPTOL_ +val SCE_SCRIPTOL_DEFAULT=0 +val SCE_SCRIPTOL_WHITE=1 +val SCE_SCRIPTOL_COMMENTLINE=2 +val SCE_SCRIPTOL_PERSISTENT=3 +val SCE_SCRIPTOL_CSTYLE=4 +val SCE_SCRIPTOL_COMMENTBLOCK=5 +val SCE_SCRIPTOL_NUMBER=6 +val SCE_SCRIPTOL_STRING=7 +val SCE_SCRIPTOL_CHARACTER=8 +val SCE_SCRIPTOL_STRINGEOL=9 +val SCE_SCRIPTOL_KEYWORD=10 +val SCE_SCRIPTOL_OPERATOR=11 +val SCE_SCRIPTOL_IDENTIFIER=12 +val SCE_SCRIPTOL_TRIPLE=13 +val SCE_SCRIPTOL_CLASSNAME=14 +val SCE_SCRIPTOL_PREPROCESSOR=15 +# Lexical states for SCLEX_ASM +lex Asm=SCLEX_ASM SCE_ASM_ +val SCE_ASM_DEFAULT=0 +val SCE_ASM_COMMENT=1 +val SCE_ASM_NUMBER=2 +val SCE_ASM_STRING=3 +val SCE_ASM_OPERATOR=4 +val SCE_ASM_IDENTIFIER=5 +val SCE_ASM_CPUINSTRUCTION=6 +val SCE_ASM_MATHINSTRUCTION=7 +val SCE_ASM_REGISTER=8 +val SCE_ASM_DIRECTIVE=9 +val SCE_ASM_DIRECTIVEOPERAND=10 +val SCE_ASM_COMMENTBLOCK=11 +val SCE_ASM_CHARACTER=12 +val SCE_ASM_STRINGEOL=13 +val SCE_ASM_EXTINSTRUCTION=14 +# Lexical states for SCLEX_FORTRAN +lex Fortran=SCLEX_FORTRAN SCE_F_ +lex F77=SCLEX_F77 SCE_F_ +val SCE_F_DEFAULT=0 +val SCE_F_COMMENT=1 +val SCE_F_NUMBER=2 +val SCE_F_STRING1=3 +val SCE_F_STRING2=4 +val SCE_F_STRINGEOL=5 +val SCE_F_OPERATOR=6 +val SCE_F_IDENTIFIER=7 +val SCE_F_WORD=8 +val SCE_F_WORD2=9 +val SCE_F_WORD3=10 +val SCE_F_PREPROCESSOR=11 +val SCE_F_OPERATOR2=12 +val SCE_F_LABEL=13 +val SCE_F_CONTINUATION=14 +# Lexical states for SCLEX_CSS +lex CSS=SCLEX_CSS SCE_CSS_ +val SCE_CSS_DEFAULT=0 +val SCE_CSS_TAG=1 +val SCE_CSS_CLASS=2 +val SCE_CSS_PSEUDOCLASS=3 +val SCE_CSS_UNKNOWN_PSEUDOCLASS=4 +val SCE_CSS_OPERATOR=5 +val SCE_CSS_IDENTIFIER=6 +val SCE_CSS_UNKNOWN_IDENTIFIER=7 +val SCE_CSS_VALUE=8 +val SCE_CSS_COMMENT=9 +val SCE_CSS_ID=10 +val SCE_CSS_IMPORTANT=11 +val SCE_CSS_DIRECTIVE=12 +val SCE_CSS_DOUBLESTRING=13 +val SCE_CSS_SINGLESTRING=14 +val SCE_CSS_IDENTIFIER2=15 +val SCE_CSS_ATTRIBUTE=16 +val SCE_CSS_IDENTIFIER3=17 +val SCE_CSS_PSEUDOELEMENT=18 +val SCE_CSS_EXTENDED_IDENTIFIER=19 +val SCE_CSS_EXTENDED_PSEUDOCLASS=20 +val SCE_CSS_EXTENDED_PSEUDOELEMENT=21 +val SCE_CSS_MEDIA=22 +# Lexical states for SCLEX_POV +lex POV=SCLEX_POV SCE_POV_ +val SCE_POV_DEFAULT=0 +val SCE_POV_COMMENT=1 +val SCE_POV_COMMENTLINE=2 +val SCE_POV_NUMBER=3 +val SCE_POV_OPERATOR=4 +val SCE_POV_IDENTIFIER=5 +val SCE_POV_STRING=6 +val SCE_POV_STRINGEOL=7 +val SCE_POV_DIRECTIVE=8 +val SCE_POV_BADDIRECTIVE=9 +val SCE_POV_WORD2=10 +val SCE_POV_WORD3=11 +val SCE_POV_WORD4=12 +val SCE_POV_WORD5=13 +val SCE_POV_WORD6=14 +val SCE_POV_WORD7=15 +val SCE_POV_WORD8=16 +# Lexical states for SCLEX_LOUT +lex LOUT=SCLEX_LOUT SCE_LOUT_ +val SCE_LOUT_DEFAULT=0 +val SCE_LOUT_COMMENT=1 +val SCE_LOUT_NUMBER=2 +val SCE_LOUT_WORD=3 +val SCE_LOUT_WORD2=4 +val SCE_LOUT_WORD3=5 +val SCE_LOUT_WORD4=6 +val SCE_LOUT_STRING=7 +val SCE_LOUT_OPERATOR=8 +val SCE_LOUT_IDENTIFIER=9 +val SCE_LOUT_STRINGEOL=10 +# Lexical states for SCLEX_ESCRIPT +lex ESCRIPT=SCLEX_ESCRIPT SCE_ESCRIPT_ +val SCE_ESCRIPT_DEFAULT=0 +val SCE_ESCRIPT_COMMENT=1 +val SCE_ESCRIPT_COMMENTLINE=2 +val SCE_ESCRIPT_COMMENTDOC=3 +val SCE_ESCRIPT_NUMBER=4 +val SCE_ESCRIPT_WORD=5 +val SCE_ESCRIPT_STRING=6 +val SCE_ESCRIPT_OPERATOR=7 +val SCE_ESCRIPT_IDENTIFIER=8 +val SCE_ESCRIPT_BRACE=9 +val SCE_ESCRIPT_WORD2=10 +val SCE_ESCRIPT_WORD3=11 +# Lexical states for SCLEX_PS +lex PS=SCLEX_PS SCE_PS_ +val SCE_PS_DEFAULT=0 +val SCE_PS_COMMENT=1 +val SCE_PS_DSC_COMMENT=2 +val SCE_PS_DSC_VALUE=3 +val SCE_PS_NUMBER=4 +val SCE_PS_NAME=5 +val SCE_PS_KEYWORD=6 +val SCE_PS_LITERAL=7 +val SCE_PS_IMMEVAL=8 +val SCE_PS_PAREN_ARRAY=9 +val SCE_PS_PAREN_DICT=10 +val SCE_PS_PAREN_PROC=11 +val SCE_PS_TEXT=12 +val SCE_PS_HEXSTRING=13 +val SCE_PS_BASE85STRING=14 +val SCE_PS_BADSTRINGCHAR=15 +# Lexical states for SCLEX_NSIS +lex NSIS=SCLEX_NSIS SCE_NSIS_ +val SCE_NSIS_DEFAULT=0 +val SCE_NSIS_COMMENT=1 +val SCE_NSIS_STRINGDQ=2 +val SCE_NSIS_STRINGLQ=3 +val SCE_NSIS_STRINGRQ=4 +val SCE_NSIS_FUNCTION=5 +val SCE_NSIS_VARIABLE=6 +val SCE_NSIS_LABEL=7 +val SCE_NSIS_USERDEFINED=8 +val SCE_NSIS_SECTIONDEF=9 +val SCE_NSIS_SUBSECTIONDEF=10 +val SCE_NSIS_IFDEFINEDEF=11 +val SCE_NSIS_MACRODEF=12 +val SCE_NSIS_STRINGVAR=13 +val SCE_NSIS_NUMBER=14 +val SCE_NSIS_SECTIONGROUP=15 +val SCE_NSIS_PAGEEX=16 +val SCE_NSIS_FUNCTIONDEF=17 +val SCE_NSIS_COMMENTBOX=18 +# Lexical states for SCLEX_MMIXAL +lex MMIXAL=SCLEX_MMIXAL SCE_MMIXAL_ +val SCE_MMIXAL_LEADWS=0 +val SCE_MMIXAL_COMMENT=1 +val SCE_MMIXAL_LABEL=2 +val SCE_MMIXAL_OPCODE=3 +val SCE_MMIXAL_OPCODE_PRE=4 +val SCE_MMIXAL_OPCODE_VALID=5 +val SCE_MMIXAL_OPCODE_UNKNOWN=6 +val SCE_MMIXAL_OPCODE_POST=7 +val SCE_MMIXAL_OPERANDS=8 +val SCE_MMIXAL_NUMBER=9 +val SCE_MMIXAL_REF=10 +val SCE_MMIXAL_CHAR=11 +val SCE_MMIXAL_STRING=12 +val SCE_MMIXAL_REGISTER=13 +val SCE_MMIXAL_HEX=14 +val SCE_MMIXAL_OPERATOR=15 +val SCE_MMIXAL_SYMBOL=16 +val SCE_MMIXAL_INCLUDE=17 +# Lexical states for SCLEX_CLW +lex Clarion=SCLEX_CLW SCE_CLW_ +val SCE_CLW_DEFAULT=0 +val SCE_CLW_LABEL=1 +val SCE_CLW_COMMENT=2 +val SCE_CLW_STRING=3 +val SCE_CLW_USER_IDENTIFIER=4 +val SCE_CLW_INTEGER_CONSTANT=5 +val SCE_CLW_REAL_CONSTANT=6 +val SCE_CLW_PICTURE_STRING=7 +val SCE_CLW_KEYWORD=8 +val SCE_CLW_COMPILER_DIRECTIVE=9 +val SCE_CLW_RUNTIME_EXPRESSIONS=10 +val SCE_CLW_BUILTIN_PROCEDURES_FUNCTION=11 +val SCE_CLW_STRUCTURE_DATA_TYPE=12 +val SCE_CLW_ATTRIBUTE=13 +val SCE_CLW_STANDARD_EQUATE=14 +val SCE_CLW_ERROR=15 +val SCE_CLW_DEPRECATED=16 +# Lexical states for SCLEX_LOT +lex LOT=SCLEX_LOT SCE_LOT_ +val SCE_LOT_DEFAULT=0 +val SCE_LOT_HEADER=1 +val SCE_LOT_BREAK=2 +val SCE_LOT_SET=3 +val SCE_LOT_PASS=4 +val SCE_LOT_FAIL=5 +val SCE_LOT_ABORT=6 +# Lexical states for SCLEX_YAML +lex YAML=SCLEX_YAML SCE_YAML_ +val SCE_YAML_DEFAULT=0 +val SCE_YAML_COMMENT=1 +val SCE_YAML_IDENTIFIER=2 +val SCE_YAML_KEYWORD=3 +val SCE_YAML_NUMBER=4 +val SCE_YAML_REFERENCE=5 +val SCE_YAML_DOCUMENT=6 +val SCE_YAML_TEXT=7 +val SCE_YAML_ERROR=8 +val SCE_YAML_OPERATOR=9 +# Lexical states for SCLEX_TEX +lex TeX=SCLEX_TEX SCE_TEX_ +val SCE_TEX_DEFAULT=0 +val SCE_TEX_SPECIAL=1 +val SCE_TEX_GROUP=2 +val SCE_TEX_SYMBOL=3 +val SCE_TEX_COMMAND=4 +val SCE_TEX_TEXT=5 +lex Metapost=SCLEX_METAPOST SCE_METAPOST_ +val SCE_METAPOST_DEFAULT=0 +val SCE_METAPOST_SPECIAL=1 +val SCE_METAPOST_GROUP=2 +val SCE_METAPOST_SYMBOL=3 +val SCE_METAPOST_COMMAND=4 +val SCE_METAPOST_TEXT=5 +val SCE_METAPOST_EXTRA=6 +# Lexical states for SCLEX_ERLANG +lex Erlang=SCLEX_ERLANG SCE_ERLANG_ +val SCE_ERLANG_DEFAULT=0 +val SCE_ERLANG_COMMENT=1 +val SCE_ERLANG_VARIABLE=2 +val SCE_ERLANG_NUMBER=3 +val SCE_ERLANG_KEYWORD=4 +val SCE_ERLANG_STRING=5 +val SCE_ERLANG_OPERATOR=6 +val SCE_ERLANG_ATOM=7 +val SCE_ERLANG_FUNCTION_NAME=8 +val SCE_ERLANG_CHARACTER=9 +val SCE_ERLANG_MACRO=10 +val SCE_ERLANG_RECORD=11 +val SCE_ERLANG_PREPROC=12 +val SCE_ERLANG_NODE_NAME=13 +val SCE_ERLANG_COMMENT_FUNCTION=14 +val SCE_ERLANG_COMMENT_MODULE=15 +val SCE_ERLANG_COMMENT_DOC=16 +val SCE_ERLANG_COMMENT_DOC_MACRO=17 +val SCE_ERLANG_ATOM_QUOTED=18 +val SCE_ERLANG_MACRO_QUOTED=19 +val SCE_ERLANG_RECORD_QUOTED=20 +val SCE_ERLANG_NODE_NAME_QUOTED=21 +val SCE_ERLANG_BIFS=22 +val SCE_ERLANG_MODULES=23 +val SCE_ERLANG_MODULES_ATT=24 +val SCE_ERLANG_UNKNOWN=31 +# Lexical states for SCLEX_OCTAVE are identical to MatLab +lex Octave=SCLEX_OCTAVE SCE_MATLAB_ +# Lexical states for SCLEX_MSSQL +lex MSSQL=SCLEX_MSSQL SCE_MSSQL_ +val SCE_MSSQL_DEFAULT=0 +val SCE_MSSQL_COMMENT=1 +val SCE_MSSQL_LINE_COMMENT=2 +val SCE_MSSQL_NUMBER=3 +val SCE_MSSQL_STRING=4 +val SCE_MSSQL_OPERATOR=5 +val SCE_MSSQL_IDENTIFIER=6 +val SCE_MSSQL_VARIABLE=7 +val SCE_MSSQL_COLUMN_NAME=8 +val SCE_MSSQL_STATEMENT=9 +val SCE_MSSQL_DATATYPE=10 +val SCE_MSSQL_SYSTABLE=11 +val SCE_MSSQL_GLOBAL_VARIABLE=12 +val SCE_MSSQL_FUNCTION=13 +val SCE_MSSQL_STORED_PROCEDURE=14 +val SCE_MSSQL_DEFAULT_PREF_DATATYPE=15 +val SCE_MSSQL_COLUMN_NAME_2=16 +# Lexical states for SCLEX_VERILOG +lex Verilog=SCLEX_VERILOG SCE_V_ +val SCE_V_DEFAULT=0 +val SCE_V_COMMENT=1 +val SCE_V_COMMENTLINE=2 +val SCE_V_COMMENTLINEBANG=3 +val SCE_V_NUMBER=4 +val SCE_V_WORD=5 +val SCE_V_STRING=6 +val SCE_V_WORD2=7 +val SCE_V_WORD3=8 +val SCE_V_PREPROCESSOR=9 +val SCE_V_OPERATOR=10 +val SCE_V_IDENTIFIER=11 +val SCE_V_STRINGEOL=12 +val SCE_V_USER=19 +# Lexical states for SCLEX_KIX +lex Kix=SCLEX_KIX SCE_KIX_ +val SCE_KIX_DEFAULT=0 +val SCE_KIX_COMMENT=1 +val SCE_KIX_STRING1=2 +val SCE_KIX_STRING2=3 +val SCE_KIX_NUMBER=4 +val SCE_KIX_VAR=5 +val SCE_KIX_MACRO=6 +val SCE_KIX_KEYWORD=7 +val SCE_KIX_FUNCTIONS=8 +val SCE_KIX_OPERATOR=9 +val SCE_KIX_IDENTIFIER=31 +# Lexical states for SCLEX_GUI4CLI +val SCE_GC_DEFAULT=0 +val SCE_GC_COMMENTLINE=1 +val SCE_GC_COMMENTBLOCK=2 +val SCE_GC_GLOBAL=3 +val SCE_GC_EVENT=4 +val SCE_GC_ATTRIBUTE=5 +val SCE_GC_CONTROL=6 +val SCE_GC_COMMAND=7 +val SCE_GC_STRING=8 +val SCE_GC_OPERATOR=9 +# Lexical states for SCLEX_SPECMAN +lex Specman=SCLEX_SPECMAN SCE_SN_ +val SCE_SN_DEFAULT=0 +val SCE_SN_CODE=1 +val SCE_SN_COMMENTLINE=2 +val SCE_SN_COMMENTLINEBANG=3 +val SCE_SN_NUMBER=4 +val SCE_SN_WORD=5 +val SCE_SN_STRING=6 +val SCE_SN_WORD2=7 +val SCE_SN_WORD3=8 +val SCE_SN_PREPROCESSOR=9 +val SCE_SN_OPERATOR=10 +val SCE_SN_IDENTIFIER=11 +val SCE_SN_STRINGEOL=12 +val SCE_SN_REGEXTAG=13 +val SCE_SN_SIGNAL=14 +val SCE_SN_USER=19 +# Lexical states for SCLEX_AU3 +lex Au3=SCLEX_AU3 SCE_AU3_ +val SCE_AU3_DEFAULT=0 +val SCE_AU3_COMMENT=1 +val SCE_AU3_COMMENTBLOCK=2 +val SCE_AU3_NUMBER=3 +val SCE_AU3_FUNCTION=4 +val SCE_AU3_KEYWORD=5 +val SCE_AU3_MACRO=6 +val SCE_AU3_STRING=7 +val SCE_AU3_OPERATOR=8 +val SCE_AU3_VARIABLE=9 +val SCE_AU3_SENT=10 +val SCE_AU3_PREPROCESSOR=11 +val SCE_AU3_SPECIAL=12 +val SCE_AU3_EXPAND=13 +val SCE_AU3_COMOBJ=14 +val SCE_AU3_UDF=15 +# Lexical states for SCLEX_APDL +lex APDL=SCLEX_APDL SCE_APDL_ +val SCE_APDL_DEFAULT=0 +val SCE_APDL_COMMENT=1 +val SCE_APDL_COMMENTBLOCK=2 +val SCE_APDL_NUMBER=3 +val SCE_APDL_STRING=4 +val SCE_APDL_OPERATOR=5 +val SCE_APDL_WORD=6 +val SCE_APDL_PROCESSOR=7 +val SCE_APDL_COMMAND=8 +val SCE_APDL_SLASHCOMMAND=9 +val SCE_APDL_STARCOMMAND=10 +val SCE_APDL_ARGUMENT=11 +val SCE_APDL_FUNCTION=12 +# Lexical states for SCLEX_BASH +lex Bash=SCLEX_BASH SCE_SH_ +val SCE_SH_DEFAULT=0 +val SCE_SH_ERROR=1 +val SCE_SH_COMMENTLINE=2 +val SCE_SH_NUMBER=3 +val SCE_SH_WORD=4 +val SCE_SH_STRING=5 +val SCE_SH_CHARACTER=6 +val SCE_SH_OPERATOR=7 +val SCE_SH_IDENTIFIER=8 +val SCE_SH_SCALAR=9 +val SCE_SH_PARAM=10 +val SCE_SH_BACKTICKS=11 +val SCE_SH_HERE_DELIM=12 +val SCE_SH_HERE_Q=13 +# Lexical states for SCLEX_ASN1 +lex Asn1=SCLEX_ASN1 SCE_ASN1_ +val SCE_ASN1_DEFAULT=0 +val SCE_ASN1_COMMENT=1 +val SCE_ASN1_IDENTIFIER=2 +val SCE_ASN1_STRING=3 +val SCE_ASN1_OID=4 +val SCE_ASN1_SCALAR=5 +val SCE_ASN1_KEYWORD=6 +val SCE_ASN1_ATTRIBUTE=7 +val SCE_ASN1_DESCRIPTOR=8 +val SCE_ASN1_TYPE=9 +val SCE_ASN1_OPERATOR=10 +# Lexical states for SCLEX_VHDL +lex VHDL=SCLEX_VHDL SCE_VHDL_ +val SCE_VHDL_DEFAULT=0 +val SCE_VHDL_COMMENT=1 +val SCE_VHDL_COMMENTLINEBANG=2 +val SCE_VHDL_NUMBER=3 +val SCE_VHDL_STRING=4 +val SCE_VHDL_OPERATOR=5 +val SCE_VHDL_IDENTIFIER=6 +val SCE_VHDL_STRINGEOL=7 +val SCE_VHDL_KEYWORD=8 +val SCE_VHDL_STDOPERATOR=9 +val SCE_VHDL_ATTRIBUTE=10 +val SCE_VHDL_STDFUNCTION=11 +val SCE_VHDL_STDPACKAGE=12 +val SCE_VHDL_STDTYPE=13 +val SCE_VHDL_USERWORD=14 +# Lexical states for SCLEX_CAML +lex Caml=SCLEX_CAML SCE_CAML_ +val SCE_CAML_DEFAULT=0 +val SCE_CAML_IDENTIFIER=1 +val SCE_CAML_TAGNAME=2 +val SCE_CAML_KEYWORD=3 +val SCE_CAML_KEYWORD2=4 +val SCE_CAML_KEYWORD3=5 +val SCE_CAML_LINENUM=6 +val SCE_CAML_OPERATOR=7 +val SCE_CAML_NUMBER=8 +val SCE_CAML_CHAR=9 +val SCE_CAML_WHITE=10 +val SCE_CAML_STRING=11 +val SCE_CAML_COMMENT=12 +val SCE_CAML_COMMENT1=13 +val SCE_CAML_COMMENT2=14 +val SCE_CAML_COMMENT3=15 +# Lexical states for SCLEX_HASKELL +lex Haskell=SCLEX_HASKELL SCE_HA_ +val SCE_HA_DEFAULT=0 +val SCE_HA_IDENTIFIER=1 +val SCE_HA_KEYWORD=2 +val SCE_HA_NUMBER=3 +val SCE_HA_STRING=4 +val SCE_HA_CHARACTER=5 +val SCE_HA_CLASS=6 +val SCE_HA_MODULE=7 +val SCE_HA_CAPITAL=8 +val SCE_HA_DATA=9 +val SCE_HA_IMPORT=10 +val SCE_HA_OPERATOR=11 +val SCE_HA_INSTANCE=12 +val SCE_HA_COMMENTLINE=13 +val SCE_HA_COMMENTBLOCK=14 +val SCE_HA_COMMENTBLOCK2=15 +val SCE_HA_COMMENTBLOCK3=16 +# Lexical states of SCLEX_TADS3 +lex TADS3=SCLEX_TADS3 SCE_T3_ +val SCE_T3_DEFAULT=0 +val SCE_T3_X_DEFAULT=1 +val SCE_T3_PREPROCESSOR=2 +val SCE_T3_BLOCK_COMMENT=3 +val SCE_T3_LINE_COMMENT=4 +val SCE_T3_OPERATOR=5 +val SCE_T3_KEYWORD=6 +val SCE_T3_NUMBER=7 +val SCE_T3_IDENTIFIER=8 +val SCE_T3_S_STRING=9 +val SCE_T3_D_STRING=10 +val SCE_T3_X_STRING=11 +val SCE_T3_LIB_DIRECTIVE=12 +val SCE_T3_MSG_PARAM=13 +val SCE_T3_HTML_TAG=14 +val SCE_T3_HTML_DEFAULT=15 +val SCE_T3_HTML_STRING=16 +val SCE_T3_USER1=17 +val SCE_T3_USER2=18 +val SCE_T3_USER3=19 +val SCE_T3_BRACE=20 +# Lexical states for SCLEX_REBOL +lex Rebol=SCLEX_REBOL SCE_REBOL_ +val SCE_REBOL_DEFAULT=0 +val SCE_REBOL_COMMENTLINE=1 +val SCE_REBOL_COMMENTBLOCK=2 +val SCE_REBOL_PREFACE=3 +val SCE_REBOL_OPERATOR=4 +val SCE_REBOL_CHARACTER=5 +val SCE_REBOL_QUOTEDSTRING=6 +val SCE_REBOL_BRACEDSTRING=7 +val SCE_REBOL_NUMBER=8 +val SCE_REBOL_PAIR=9 +val SCE_REBOL_TUPLE=10 +val SCE_REBOL_BINARY=11 +val SCE_REBOL_MONEY=12 +val SCE_REBOL_ISSUE=13 +val SCE_REBOL_TAG=14 +val SCE_REBOL_FILE=15 +val SCE_REBOL_EMAIL=16 +val SCE_REBOL_URL=17 +val SCE_REBOL_DATE=18 +val SCE_REBOL_TIME=19 +val SCE_REBOL_IDENTIFIER=20 +val SCE_REBOL_WORD=21 +val SCE_REBOL_WORD2=22 +val SCE_REBOL_WORD3=23 +val SCE_REBOL_WORD4=24 +val SCE_REBOL_WORD5=25 +val SCE_REBOL_WORD6=26 +val SCE_REBOL_WORD7=27 +val SCE_REBOL_WORD8=28 +# Lexical states for SCLEX_SQL +lex SQL=SCLEX_SQL SCE_SQL_ +val SCE_SQL_DEFAULT=0 +val SCE_SQL_COMMENT=1 +val SCE_SQL_COMMENTLINE=2 +val SCE_SQL_COMMENTDOC=3 +val SCE_SQL_NUMBER=4 +val SCE_SQL_WORD=5 +val SCE_SQL_STRING=6 +val SCE_SQL_CHARACTER=7 +val SCE_SQL_SQLPLUS=8 +val SCE_SQL_SQLPLUS_PROMPT=9 +val SCE_SQL_OPERATOR=10 +val SCE_SQL_IDENTIFIER=11 +val SCE_SQL_SQLPLUS_COMMENT=13 +val SCE_SQL_COMMENTLINEDOC=15 +val SCE_SQL_WORD2=16 +val SCE_SQL_COMMENTDOCKEYWORD=17 +val SCE_SQL_COMMENTDOCKEYWORDERROR=18 +val SCE_SQL_USER1=19 +val SCE_SQL_USER2=20 +val SCE_SQL_USER3=21 +val SCE_SQL_USER4=22 +val SCE_SQL_QUOTEDIDENTIFIER=23 +# Lexical states for SCLEX_SMALLTALK +lex Smalltalk=SCLEX_SMALLTALK SCE_ST_ +val SCE_ST_DEFAULT=0 +val SCE_ST_STRING=1 +val SCE_ST_NUMBER=2 +val SCE_ST_COMMENT=3 +val SCE_ST_SYMBOL=4 +val SCE_ST_BINARY=5 +val SCE_ST_BOOL=6 +val SCE_ST_SELF=7 +val SCE_ST_SUPER=8 +val SCE_ST_NIL=9 +val SCE_ST_GLOBAL=10 +val SCE_ST_RETURN=11 +val SCE_ST_SPECIAL=12 +val SCE_ST_KWSEND=13 +val SCE_ST_ASSIGN=14 +val SCE_ST_CHARACTER=15 +val SCE_ST_SPEC_SEL=16 +# Lexical states for SCLEX_FLAGSHIP (clipper) +lex FlagShip=SCLEX_FLAGSHIP SCE_FS_ +val SCE_FS_DEFAULT=0 +val SCE_FS_COMMENT=1 +val SCE_FS_COMMENTLINE=2 +val SCE_FS_COMMENTDOC=3 +val SCE_FS_COMMENTLINEDOC=4 +val SCE_FS_COMMENTDOCKEYWORD=5 +val SCE_FS_COMMENTDOCKEYWORDERROR=6 +val SCE_FS_KEYWORD=7 +val SCE_FS_KEYWORD2=8 +val SCE_FS_KEYWORD3=9 +val SCE_FS_KEYWORD4=10 +val SCE_FS_NUMBER=11 +val SCE_FS_STRING=12 +val SCE_FS_PREPROCESSOR=13 +val SCE_FS_OPERATOR=14 +val SCE_FS_IDENTIFIER=15 +val SCE_FS_DATE=16 +val SCE_FS_STRINGEOL=17 +val SCE_FS_CONSTANT=18 +val SCE_FS_WORDOPERATOR=19 +val SCE_FS_DISABLEDCODE=20 +val SCE_FS_DEFAULT_C=21 +val SCE_FS_COMMENTDOC_C=22 +val SCE_FS_COMMENTLINEDOC_C=23 +val SCE_FS_KEYWORD_C=24 +val SCE_FS_KEYWORD2_C=25 +val SCE_FS_NUMBER_C=26 +val SCE_FS_STRING_C=27 +val SCE_FS_PREPROCESSOR_C=28 +val SCE_FS_OPERATOR_C=29 +val SCE_FS_IDENTIFIER_C=30 +val SCE_FS_STRINGEOL_C=31 +# Lexical states for SCLEX_CSOUND +lex Csound=SCLEX_CSOUND SCE_CSOUND_ +val SCE_CSOUND_DEFAULT=0 +val SCE_CSOUND_COMMENT=1 +val SCE_CSOUND_NUMBER=2 +val SCE_CSOUND_OPERATOR=3 +val SCE_CSOUND_INSTR=4 +val SCE_CSOUND_IDENTIFIER=5 +val SCE_CSOUND_OPCODE=6 +val SCE_CSOUND_HEADERSTMT=7 +val SCE_CSOUND_USERKEYWORD=8 +val SCE_CSOUND_COMMENTBLOCK=9 +val SCE_CSOUND_PARAM=10 +val SCE_CSOUND_ARATE_VAR=11 +val SCE_CSOUND_KRATE_VAR=12 +val SCE_CSOUND_IRATE_VAR=13 +val SCE_CSOUND_GLOBAL_VAR=14 +val SCE_CSOUND_STRINGEOL=15 +# Lexical states for SCLEX_INNOSETUP +lex Inno=SCLEX_INNOSETUP SCE_INNO_ +val SCE_INNO_DEFAULT=0 +val SCE_INNO_COMMENT=1 +val SCE_INNO_KEYWORD=2 +val SCE_INNO_PARAMETER=3 +val SCE_INNO_SECTION=4 +val SCE_INNO_PREPROC=5 +val SCE_INNO_INLINE_EXPANSION=6 +val SCE_INNO_COMMENT_PASCAL=7 +val SCE_INNO_KEYWORD_PASCAL=8 +val SCE_INNO_KEYWORD_USER=9 +val SCE_INNO_STRING_DOUBLE=10 +val SCE_INNO_STRING_SINGLE=11 +val SCE_INNO_IDENTIFIER=12 +# Lexical states for SCLEX_OPAL +lex Opal=SCLEX_OPAL SCE_OPAL_ +val SCE_OPAL_SPACE=0 +val SCE_OPAL_COMMENT_BLOCK=1 +val SCE_OPAL_COMMENT_LINE=2 +val SCE_OPAL_INTEGER=3 +val SCE_OPAL_KEYWORD=4 +val SCE_OPAL_SORT=5 +val SCE_OPAL_STRING=6 +val SCE_OPAL_PAR=7 +val SCE_OPAL_BOOL_CONST=8 +val SCE_OPAL_DEFAULT=32 +# Lexical states for SCLEX_SPICE +lex Spice=SCLEX_SPICE SCE_SPICE_ +val SCE_SPICE_DEFAULT=0 +val SCE_SPICE_IDENTIFIER=1 +val SCE_SPICE_KEYWORD=2 +val SCE_SPICE_KEYWORD2=3 +val SCE_SPICE_KEYWORD3=4 +val SCE_SPICE_NUMBER=5 +val SCE_SPICE_DELIMITER=6 +val SCE_SPICE_VALUE=7 +val SCE_SPICE_COMMENTLINE=8 +# Lexical states for SCLEX_CMAKE +lex CMAKE=SCLEX_CMAKE SCE_CMAKE_ +val SCE_CMAKE_DEFAULT=0 +val SCE_CMAKE_COMMENT=1 +val SCE_CMAKE_STRINGDQ=2 +val SCE_CMAKE_STRINGLQ=3 +val SCE_CMAKE_STRINGRQ=4 +val SCE_CMAKE_COMMANDS=5 +val SCE_CMAKE_PARAMETERS=6 +val SCE_CMAKE_VARIABLE=7 +val SCE_CMAKE_USERDEFINED=8 +val SCE_CMAKE_WHILEDEF=9 +val SCE_CMAKE_FOREACHDEF=10 +val SCE_CMAKE_IFDEFINEDEF=11 +val SCE_CMAKE_MACRODEF=12 +val SCE_CMAKE_STRINGVAR=13 +val SCE_CMAKE_NUMBER=14 +# Lexical states for SCLEX_GAP +lex Gap=SCLEX_GAP SCE_GAP_ +val SCE_GAP_DEFAULT=0 +val SCE_GAP_IDENTIFIER=1 +val SCE_GAP_KEYWORD=2 +val SCE_GAP_KEYWORD2=3 +val SCE_GAP_KEYWORD3=4 +val SCE_GAP_KEYWORD4=5 +val SCE_GAP_STRING=6 +val SCE_GAP_CHAR=7 +val SCE_GAP_OPERATOR=8 +val SCE_GAP_COMMENT=9 +val SCE_GAP_NUMBER=10 +val SCE_GAP_STRINGEOL=11 +# Lexical state for SCLEX_PLM +lex PLM=SCLEX_PLM SCE_PLM_ +val SCE_PLM_DEFAULT=0 +val SCE_PLM_COMMENT=1 +val SCE_PLM_STRING=2 +val SCE_PLM_NUMBER=3 +val SCE_PLM_IDENTIFIER=4 +val SCE_PLM_OPERATOR=5 +val SCE_PLM_CONTROL=6 +val SCE_PLM_KEYWORD=7 +# Lexical state for SCLEX_PROGRESS +lex Progress=SCLEX_PROGRESS SCE_4GL_ +val SCE_4GL_DEFAULT=0 +val SCE_4GL_NUMBER=1 +val SCE_4GL_WORD=2 +val SCE_4GL_STRING=3 +val SCE_4GL_CHARACTER=4 +val SCE_4GL_PREPROCESSOR=5 +val SCE_4GL_OPERATOR=6 +val SCE_4GL_IDENTIFIER=7 +val SCE_4GL_BLOCK=8 +val SCE_4GL_END=9 +val SCE_4GL_COMMENT1=10 +val SCE_4GL_COMMENT2=11 +val SCE_4GL_COMMENT3=12 +val SCE_4GL_COMMENT4=13 +val SCE_4GL_COMMENT5=14 +val SCE_4GL_COMMENT6=15 +val SCE_4GL_DEFAULT_=16 +val SCE_4GL_NUMBER_=17 +val SCE_4GL_WORD_=18 +val SCE_4GL_STRING_=19 +val SCE_4GL_CHARACTER_=20 +val SCE_4GL_PREPROCESSOR_=21 +val SCE_4GL_OPERATOR_=22 +val SCE_4GL_IDENTIFIER_=23 +val SCE_4GL_BLOCK_=24 +val SCE_4GL_END_=25 +val SCE_4GL_COMMENT1_=26 +val SCE_4GL_COMMENT2_=27 +val SCE_4GL_COMMENT3_=28 +val SCE_4GL_COMMENT4_=29 +val SCE_4GL_COMMENT5_=30 +val SCE_4GL_COMMENT6_=31 +# Lexical states for SCLEX_ABAQUS +lex ABAQUS=SCLEX_ABAQUS SCE_ABAQUS_ +val SCE_ABAQUS_DEFAULT=0 +val SCE_ABAQUS_COMMENT=1 +val SCE_ABAQUS_COMMENTBLOCK=2 +val SCE_ABAQUS_NUMBER=3 +val SCE_ABAQUS_STRING=4 +val SCE_ABAQUS_OPERATOR=5 +val SCE_ABAQUS_WORD=6 +val SCE_ABAQUS_PROCESSOR=7 +val SCE_ABAQUS_COMMAND=8 +val SCE_ABAQUS_SLASHCOMMAND=9 +val SCE_ABAQUS_STARCOMMAND=10 +val SCE_ABAQUS_ARGUMENT=11 +val SCE_ABAQUS_FUNCTION=12 +# Lexical states for SCLEX_ASYMPTOTE +lex Asymptote=SCLEX_ASYMPTOTE SCE_ASY_ +val SCE_ASY_DEFAULT=0 +val SCE_ASY_COMMENT=1 +val SCE_ASY_COMMENTLINE=2 +val SCE_ASY_NUMBER=3 +val SCE_ASY_WORD=4 +val SCE_ASY_STRING=5 +val SCE_ASY_CHARACTER=6 +val SCE_ASY_OPERATOR=7 +val SCE_ASY_IDENTIFIER=8 +val SCE_ASY_STRINGEOL=9 +val SCE_ASY_COMMENTLINEDOC=10 +val SCE_ASY_WORD2=11 +# Lexical states for SCLEX_R +lex R=SCLEX_R SCE_R_ +val SCE_R_DEFAULT=0 +val SCE_R_COMMENT=1 +val SCE_R_KWORD=2 +val SCE_R_BASEKWORD=3 +val SCE_R_OTHERKWORD=4 +val SCE_R_NUMBER=5 +val SCE_R_STRING=6 +val SCE_R_STRING2=7 +val SCE_R_OPERATOR=8 +val SCE_R_IDENTIFIER=9 +val SCE_R_INFIX=10 +val SCE_R_INFIXEOL=11 +# Lexical state for SCLEX_MAGIKSF +lex MagikSF=SCLEX_MAGIKSF SCE_MAGIK_ +val SCE_MAGIK_DEFAULT=0 +val SCE_MAGIK_COMMENT=1 +val SCE_MAGIK_HYPER_COMMENT=16 +val SCE_MAGIK_STRING=2 +val SCE_MAGIK_CHARACTER=3 +val SCE_MAGIK_NUMBER=4 +val SCE_MAGIK_IDENTIFIER=5 +val SCE_MAGIK_OPERATOR=6 +val SCE_MAGIK_FLOW=7 +val SCE_MAGIK_CONTAINER=8 +val SCE_MAGIK_BRACKET_BLOCK=9 +val SCE_MAGIK_BRACE_BLOCK=10 +val SCE_MAGIK_SQBRACKET_BLOCK=11 +val SCE_MAGIK_UNKNOWN_KEYWORD=12 +val SCE_MAGIK_KEYWORD=13 +val SCE_MAGIK_PRAGMA=14 +val SCE_MAGIK_SYMBOL=15 +# Lexical state for SCLEX_POWERSHELL +lex PowerShell=SCLEX_POWERSHELL SCE_POWERSHELL_ +val SCE_POWERSHELL_DEFAULT=0 +val SCE_POWERSHELL_COMMENT=1 +val SCE_POWERSHELL_STRING=2 +val SCE_POWERSHELL_CHARACTER=3 +val SCE_POWERSHELL_NUMBER=4 +val SCE_POWERSHELL_VARIABLE=5 +val SCE_POWERSHELL_OPERATOR=6 +val SCE_POWERSHELL_IDENTIFIER=7 +val SCE_POWERSHELL_KEYWORD=8 +val SCE_POWERSHELL_CMDLET=9 +val SCE_POWERSHELL_ALIAS=10 +# Lexical state for SCLEX_MYSQL +lex MySQL=SCLEX_MYSQL SCE_MYSQL_ +val SCE_MYSQL_DEFAULT=0 +val SCE_MYSQL_COMMENT=1 +val SCE_MYSQL_COMMENTLINE=2 +val SCE_MYSQL_VARIABLE=3 +val SCE_MYSQL_SYSTEMVARIABLE=4 +val SCE_MYSQL_KNOWNSYSTEMVARIABLE=5 +val SCE_MYSQL_NUMBER=6 +val SCE_MYSQL_MAJORKEYWORD=7 +val SCE_MYSQL_KEYWORD=8 +val SCE_MYSQL_DATABASEOBJECT=9 +val SCE_MYSQL_PROCEDUREKEYWORD=10 +val SCE_MYSQL_STRING=11 +val SCE_MYSQL_SQSTRING=12 +val SCE_MYSQL_DQSTRING=13 +val SCE_MYSQL_OPERATOR=14 +val SCE_MYSQL_FUNCTION=15 +val SCE_MYSQL_IDENTIFIER=16 +val SCE_MYSQL_QUOTEDIDENTIFIER=17 +val SCE_MYSQL_USER1=18 +val SCE_MYSQL_USER2=19 +val SCE_MYSQL_USER3=20 +val SCE_MYSQL_HIDDENCOMMAND=21 +# Lexical state for SCLEX_PO +lex Po=SCLEX_PO SCE_PO_ +val SCE_PO_DEFAULT=0 +val SCE_PO_COMMENT=1 +val SCE_PO_MSGID=2 +val SCE_PO_MSGID_TEXT=3 +val SCE_PO_MSGSTR=4 +val SCE_PO_MSGSTR_TEXT=5 +val SCE_PO_MSGCTXT=6 +val SCE_PO_MSGCTXT_TEXT=7 +val SCE_PO_FUZZY=8 +# Lexical states for SCLEX_PASCAL +lex Pascal=SCLEX_PASCAL SCE_PAS_ +val SCE_PAS_DEFAULT=0 +val SCE_PAS_IDENTIFIER=1 +val SCE_PAS_COMMENT=2 +val SCE_PAS_COMMENT2=3 +val SCE_PAS_COMMENTLINE=4 +val SCE_PAS_PREPROCESSOR=5 +val SCE_PAS_PREPROCESSOR2=6 +val SCE_PAS_NUMBER=7 +val SCE_PAS_HEXNUMBER=8 +val SCE_PAS_WORD=9 +val SCE_PAS_STRING=10 +val SCE_PAS_STRINGEOL=11 +val SCE_PAS_CHARACTER=12 +val SCE_PAS_OPERATOR=13 +val SCE_PAS_ASM=14 +# Lexical state for SCLEX_SORCUS +lex SORCUS=SCLEX_SORCUS SCE_SORCUS_ +val SCE_SORCUS_DEFAULT=0 +val SCE_SORCUS_COMMAND=1 +val SCE_SORCUS_PARAMETER=2 +val SCE_SORCUS_COMMENTLINE=3 +val SCE_SORCUS_STRING=4 +val SCE_SORCUS_STRINGEOL=5 +val SCE_SORCUS_IDENTIFIER=6 +val SCE_SORCUS_OPERATOR=7 +val SCE_SORCUS_NUMBER=8 +val SCE_SORCUS_CONSTANT=9 +# Lexical state for SCLEX_POWERPRO +lex PowerPro=SCLEX_POWERPRO SCE_POWERPRO_ +val SCE_POWERPRO_DEFAULT=0 +val SCE_POWERPRO_COMMENTBLOCK=1 +val SCE_POWERPRO_COMMENTLINE=2 +val SCE_POWERPRO_NUMBER=3 +val SCE_POWERPRO_WORD=4 +val SCE_POWERPRO_WORD2=5 +val SCE_POWERPRO_WORD3=6 +val SCE_POWERPRO_WORD4=7 +val SCE_POWERPRO_DOUBLEQUOTEDSTRING=8 +val SCE_POWERPRO_SINGLEQUOTEDSTRING=9 +val SCE_POWERPRO_LINECONTINUE=10 +val SCE_POWERPRO_OPERATOR=11 +val SCE_POWERPRO_IDENTIFIER=12 +val SCE_POWERPRO_STRINGEOL=13 +val SCE_POWERPRO_VERBATIM=14 +val SCE_POWERPRO_ALTQUOTE=15 +val SCE_POWERPRO_FUNCTION=16 +# Lexical states for SCLEX_SML +lex SML=SCLEX_SML SCE_SML_ +val SCE_SML_DEFAULT=0 +val SCE_SML_IDENTIFIER=1 +val SCE_SML_TAGNAME=2 +val SCE_SML_KEYWORD=3 +val SCE_SML_KEYWORD2=4 +val SCE_SML_KEYWORD3=5 +val SCE_SML_LINENUM=6 +val SCE_SML_OPERATOR=7 +val SCE_SML_NUMBER=8 +val SCE_SML_CHAR=9 +val SCE_SML_STRING=11 +val SCE_SML_COMMENT=12 +val SCE_SML_COMMENT1=13 +val SCE_SML_COMMENT2=14 +val SCE_SML_COMMENT3=15 +# Lexical state for SCLEX_MARKDOWN +lex Markdown=SCLEX_MARKDOWN SCE_MARKDOWN_ +val SCE_MARKDOWN_DEFAULT=0 +val SCE_MARKDOWN_LINE_BEGIN=1 +val SCE_MARKDOWN_STRONG1=2 +val SCE_MARKDOWN_STRONG2=3 +val SCE_MARKDOWN_EM1=4 +val SCE_MARKDOWN_EM2=5 +val SCE_MARKDOWN_HEADER1=6 +val SCE_MARKDOWN_HEADER2=7 +val SCE_MARKDOWN_HEADER3=8 +val SCE_MARKDOWN_HEADER4=9 +val SCE_MARKDOWN_HEADER5=10 +val SCE_MARKDOWN_HEADER6=11 +val SCE_MARKDOWN_PRECHAR=12 +val SCE_MARKDOWN_ULIST_ITEM=13 +val SCE_MARKDOWN_OLIST_ITEM=14 +val SCE_MARKDOWN_BLOCKQUOTE=15 +val SCE_MARKDOWN_STRIKEOUT=16 +val SCE_MARKDOWN_HRULE=17 +val SCE_MARKDOWN_LINK=18 +val SCE_MARKDOWN_CODE=19 +val SCE_MARKDOWN_CODE2=20 +val SCE_MARKDOWN_CODEBK=21 + +# Events + +evt void StyleNeeded=2000(int position) +evt void CharAdded=2001(int ch) +evt void SavePointReached=2002(void) +evt void SavePointLeft=2003(void) +evt void ModifyAttemptRO=2004(void) +# GTK+ Specific to work around focus and accelerator problems: +evt void Key=2005(int ch, int modifiers) +evt void DoubleClick=2006(void) +evt void UpdateUI=2007(void) +evt void Modified=2008(int position, int modificationType, string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev) +evt void MacroRecord=2009(int message, int wParam, int lParam) +evt void MarginClick=2010(int modifiers, int position, int margin) +evt void NeedShown=2011(int position, int length) +evt void Painted=2013(void) +evt void UserListSelection=2014(int listType, string text) +evt void URIDropped=2015(string text) +evt void DwellStart=2016(int position) +evt void DwellEnd=2017(int position) +evt void Zoom=2018(void) +evt void HotSpotClick=2019(int modifiers, int position) +evt void HotSpotDoubleClick=2020(int modifiers, int position) +evt void CallTipClick=2021(int position) +evt void AutoCSelection=2022(string text) +evt void IndicatorClick=2023(int modifiers, int position) +evt void IndicatorRelease=2024(int modifiers, int position) +evt void AutoCCancelled=2025(void) +evt void AutoCCharDeleted=2026(void) diff --git a/sdk/wxscintilla/src/scintilla/include/ScintillaWidget.h b/sdk/wxscintilla/src/scintilla/include/ScintillaWidget.h new file mode 100644 index 0000000..e3c4c79 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/ScintillaWidget.h @@ -0,0 +1,55 @@ +/* Scintilla source code edit control */ +/** @file ScintillaWidget.h + ** Definition of Scintilla widget for GTK+. + ** Only needed by GTK+ code but is harmless on other platforms. + **/ +/* Copyright 1998-2001 by Neil Hodgson + * The License.txt file describes the conditions under which this software may be distributed. */ + +#ifndef SCINTILLAWIDGET_H +#define SCINTILLAWIDGET_H + +#if defined(GTK) && !defined(__APPLE__) + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef __APPLE__ +#include +#endif + +#define SCINTILLA(obj) GTK_CHECK_CAST (obj, scintilla_get_type (), ScintillaObject) +#define SCINTILLA_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, scintilla_get_type (), ScintillaClass) +#define IS_SCINTILLA(obj) GTK_CHECK_TYPE (obj, scintilla_get_type ()) + +typedef struct _ScintillaObject ScintillaObject; +typedef struct _ScintillaClass ScintillaClass; + +struct _ScintillaObject { + GtkContainer cont; + void *pscin; +}; + +struct _ScintillaClass { + GtkContainerClass parent_class; + + void (* command) (ScintillaObject *ttt); + void (* notify) (ScintillaObject *ttt); +}; + +GType scintilla_get_type (void); +GtkWidget* scintilla_new (void); +void scintilla_set_id (ScintillaObject *sci, uptr_t id); +sptr_t scintilla_send_message (ScintillaObject *sci,unsigned int iMessage, uptr_t wParam, sptr_t lParam); +void scintilla_release_resources(void); + +#define SCINTILLA_NOTIFY "sci-notify" + +#ifdef __cplusplus +} +#endif + +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/include/WindowAccessor.h b/sdk/wxscintilla/src/scintilla/include/WindowAccessor.h new file mode 100644 index 0000000..4a86407 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/include/WindowAccessor.h @@ -0,0 +1,67 @@ +// Scintilla source code edit control +/** @file WindowAccessor.h + ** Implementation of BufferAccess and StylingAccess on a Scintilla + ** rapid easy access to contents of a Scintilla. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ + +class WindowAccessor : public Accessor { + // Private so WindowAccessor objects can not be copied + WindowAccessor(const WindowAccessor &source) : Accessor(), props(source.props) {} + WindowAccessor &operator=(const WindowAccessor &) { return *this; } +protected: + WindowID id; + PropertyGet &props; + int lenDoc; + + char styleBuf[bufferSize]; + int validLen; + char chFlags; + char chWhile; + unsigned int startSeg; + + bool InternalIsLeadByte(char ch); + void Fill(int position); +public: + WindowAccessor(WindowID id_, PropertyGet &props_) : + Accessor(), id(id_), props(props_), + lenDoc(-1), validLen(0), chFlags(0), chWhile(0) { + } + ~WindowAccessor(); + bool Match(int pos, const char *s); + char StyleAt(int position); + int GetLine(int position); + int LineStart(int line); + int LevelAt(int line); + int Length(); + void Flush(); + int GetLineState(int line); + int SetLineState(int line, int state); + int GetPropertyInt(const char *key, int defaultValue=0) { + return props.GetInt(key, defaultValue); + } + char *GetProperties() { + return props.ToString(); + } + + void StartAt(unsigned int start, char chMask=31); + void SetFlags(char chFlags_, char chWhile_) {chFlags = chFlags_; chWhile = chWhile_; } + unsigned int GetStartSegment() { return startSeg; } + void StartSegment(unsigned int pos); + void ColourTo(unsigned int pos, int chAttr); + void SetLevel(int line, int level); + int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0); + void IndicatorFill(int start, int end, int indicator, int value); +}; + +#ifdef SCI_NAMESPACE +} +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/AutoComplete.cxx b/sdk/wxscintilla/src/scintilla/src/AutoComplete.cxx new file mode 100644 index 0000000..8fba820 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/AutoComplete.cxx @@ -0,0 +1,178 @@ +// Scintilla source code edit control +/** @file AutoComplete.cxx + ** Defines the auto completion list box. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include + +#include "Platform.h" + +#include "CharClassify.h" +#include "AutoComplete.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +AutoComplete::AutoComplete() : + active(false), + separator(' '), + typesep('?'), + ignoreCase(false), + chooseSingle(false), + lb(0), + posStart(0), + startLen(0), + cancelAtStartPos(true), + autoHide(true), + dropRestOfWord(false) { + lb = ListBox::Allocate(); + stopChars[0] = '\0'; + fillUpChars[0] = '\0'; +} + +AutoComplete::~AutoComplete() { + if (lb) { + lb->Destroy(); + delete lb; + lb = 0; + } +} + +bool AutoComplete::Active() const { + return active; +} + +void AutoComplete::Start(Window &parent, int ctrlID, + int position, Point location, int startLen_, + int lineHeight, bool unicodeMode) { + if (active) { + Cancel(); + } + lb->Create(parent, ctrlID, location, lineHeight, unicodeMode); + lb->Clear(); + active = true; + startLen = startLen_; + posStart = position; +} + +void AutoComplete::SetStopChars(const char *stopChars_) { + strncpy(stopChars, stopChars_, sizeof(stopChars)); + stopChars[sizeof(stopChars) - 1] = '\0'; +} + +bool AutoComplete::IsStopChar(char ch) { + return ch && strchr(stopChars, ch); +} + +void AutoComplete::SetFillUpChars(const char *fillUpChars_) { + strncpy(fillUpChars, fillUpChars_, sizeof(fillUpChars)); + fillUpChars[sizeof(fillUpChars) - 1] = '\0'; +} + +bool AutoComplete::IsFillUpChar(char ch) { + return ch && strchr(fillUpChars, ch); +} + +void AutoComplete::SetSeparator(char separator_) { + separator = separator_; +} + +char AutoComplete::GetSeparator() const { + return separator; +} + +void AutoComplete::SetTypesep(char separator_) { + typesep = separator_; +} + +char AutoComplete::GetTypesep() const { + return typesep; +} + +void AutoComplete::SetList(const char *list) { + lb->SetList(list, separator, typesep); +} + +void AutoComplete::Show(bool show) { + lb->Show(show); + if (show) + lb->Select(0); +} + +void AutoComplete::Cancel() { + if (lb->Created()) { + lb->Clear(); + lb->Destroy(); + active = false; + } +} + + +void AutoComplete::Move(int delta) { + int count = lb->Length(); + int current = lb->GetSelection(); + current += delta; + if (current >= count) + current = count - 1; + if (current < 0) + current = 0; + lb->Select(current); +} + +void AutoComplete::Select(const char *word) { + size_t lenWord = strlen(word); + int location = -1; + const int maxItemLen=1000; + char item[maxItemLen]; + int start = 0; // lower bound of the api array block to search + int end = lb->Length() - 1; // upper bound of the api array block to search + while ((start <= end) && (location == -1)) { // Binary searching loop + int pivot = (start + end) / 2; + lb->GetValue(pivot, item, maxItemLen); + int cond; + if (ignoreCase) + cond = CompareNCaseInsensitive(word, item, lenWord); + else + cond = strncmp(word, item, lenWord); + if (!cond) { + // Find first match + while (pivot > start) { + lb->GetValue(pivot-1, item, maxItemLen); + if (ignoreCase) + cond = CompareNCaseInsensitive(word, item, lenWord); + else + cond = strncmp(word, item, lenWord); + if (0 != cond) + break; + --pivot; + } + location = pivot; + if (ignoreCase) { + // Check for exact-case match + for (; pivot <= end; pivot++) { + lb->GetValue(pivot, item, maxItemLen); + if (!strncmp(word, item, lenWord)) { + location = pivot; + break; + } + if (CompareNCaseInsensitive(word, item, lenWord)) + break; + } + } + } else if (cond < 0) { + end = pivot - 1; + } else if (cond > 0) { + start = pivot + 1; + } + } + if (location == -1 && autoHide) + Cancel(); + else + lb->Select(location); +} + diff --git a/sdk/wxscintilla/src/scintilla/src/AutoComplete.h b/sdk/wxscintilla/src/scintilla/src/AutoComplete.h new file mode 100644 index 0000000..f48cb05 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/AutoComplete.h @@ -0,0 +1,78 @@ +// Scintilla source code edit control +/** @file AutoComplete.h + ** Defines the auto completion list box. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef AUTOCOMPLETE_H +#define AUTOCOMPLETE_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ +class AutoComplete { + bool active; + char stopChars[256]; + char fillUpChars[256]; + char separator; + char typesep; // Type seperator + +public: + bool ignoreCase; + bool chooseSingle; + ListBox *lb; + int posStart; + int startLen; + /// Should autocompletion be canceled if editor's currentPos <= startPos? + bool cancelAtStartPos; + bool autoHide; + bool dropRestOfWord; + + AutoComplete(); + ~AutoComplete(); + + /// Is the auto completion list displayed? + bool Active() const; + + /// Display the auto completion list positioned to be near a character position + void Start(Window &parent, int ctrlID, int position, Point location, + int startLen_, int lineHeight, bool unicodeMode); + + /// The stop chars are characters which, when typed, cause the auto completion list to disappear + void SetStopChars(const char *stopChars_); + bool IsStopChar(char ch); + + /// The fillup chars are characters which, when typed, fill up the selected word + void SetFillUpChars(const char *fillUpChars_); + bool IsFillUpChar(char ch); + + /// The separator character is used when interpreting the list in SetList + void SetSeparator(char separator_); + char GetSeparator() const; + + /// The typesep character is used for seperating the word from the type + void SetTypesep(char separator_); + char GetTypesep() const; + + /// The list string contains a sequence of words separated by the separator character + void SetList(const char *list); + + void Show(bool show); + void Cancel(); + + /// Move the current list element by delta, scrolling appropriately + void Move(int delta); + + /// Select a list element that starts with word as the current element + void Select(const char *word); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/CallTip.cxx b/sdk/wxscintilla/src/scintilla/src/CallTip.cxx new file mode 100644 index 0000000..fe1d589 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CallTip.cxx @@ -0,0 +1,387 @@ +// Scintilla source code edit control +/** @file CallTip.cxx + ** Code for displaying call tips. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include + +#include "Platform.h" + +#include "Scintilla.h" +#include "CallTip.h" +#include + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static const int insetX = 5; // text inset in x from calltip border +static const int widthArrow = 14; + +CallTip::CallTip() { + wCallTip = 0; + inCallTipMode = false; + posStartCallTip = 0; + val = 0; + rectUp = PRectangle(0,0,0,0); + rectDown = PRectangle(0,0,0,0); + lineHeight = 1; + startHighlight = 0; + endHighlight = 0; + tabSize = 0; + useStyleCallTip = false; // for backwards compatibility + +#ifdef __APPLE__ + // proper apple colours for the default + colourBG.desired = ColourDesired(0xff, 0xff, 0xc6); + colourUnSel.desired = ColourDesired(0, 0, 0); +#else + colourBG.desired = ColourDesired(0xff, 0xff, 0xff); + colourUnSel.desired = ColourDesired(0x80, 0x80, 0x80); +#endif + colourSel.desired = ColourDesired(0, 0, 0x80); + colourShade.desired = ColourDesired(0, 0, 0); + colourLight.desired = ColourDesired(0xc0, 0xc0, 0xc0); + + // ERAN IFRAH + ColourDesired c(0, 0, 255); + ColourAllocated ca(c.AsLong()); + + colourDoxyHighlight = ca; + colourDivider = ColourAllocated(0); + // ERAN IFRAH - END +} + +CallTip::~CallTip() { + font.Release(); + wCallTip.Destroy(); + delete []val; + val = 0; +} + +void CallTip::RefreshColourPalette(Palette &pal, bool want) { + pal.WantFind(colourBG, want); + pal.WantFind(colourUnSel, want); + pal.WantFind(colourSel, want); + pal.WantFind(colourShade, want); + pal.WantFind(colourLight, want); +} + +// Although this test includes 0, we should never see a \0 character. +static bool IsArrowCharacter(char ch) { + return (ch == 0) || (ch == '\001') || (ch == '\002'); +} + +// ERAN IFRAH +static bool IsDoxyKeyWord(const char* s, int &len) { + len = 0; + if(s[0] == '@' || s[0] == '\\') { + len = 1; + for(size_t i=0; i 0; +} +// ERAN IFRAH - END + +// We ignore tabs unless a tab width has been set. +bool CallTip::IsTabCharacter(char ch) const { + return (tabSize > 0) && (ch == '\t'); +} + +int CallTip::NextTabPos(int x) { + if (tabSize > 0) { // paranoia... not called unless this is true + x -= insetX; // position relative to text + x = (x + tabSize) / tabSize; // tab "number" + return tabSize*x + insetX; // position of next tab + } else { + return x + 1; // arbitrary + } +} + +// Draw a section of the call tip that does not include \n in one colour. +// The text may include up to numEnds tabs or arrow characters. +void CallTip::DrawChunk(Surface *surface, int &x, const char *s, + int posStart, int posEnd, int ytext, PRectangle rcClient, + bool highlight, bool draw) { + s += posStart; + int len = posEnd - posStart; + + // Divide the text into sections that are all text, or that are + // single arrows or single tab characters (if tabSize > 0). + int maxEnd = 0; + const int numEnds = 10; + int ends[numEnds + 2]; + + // ERAN IFRAH + int doxyWordLen = 0; + for (int i=0;i 0) + ends[maxEnd++] = i; + ends[maxEnd++] = i+1; + } else if((maxEnd < numEnds) && IsDoxyKeyWord(s+i, doxyWordLen)) { + // we found a doxygen word + if(i > 0) + ends[maxEnd++] = i; + ends[maxEnd++] = i + doxyWordLen; + i += len; + } + } + + // If we find this magic string, we translate it into + // a horizontal line in the tip + bool isLine (false); + if(strncmp(s, "@@LINE@@", 8) == 0) { + isLine = true; + } + // ERAN IFRAH - END + + ends[maxEnd++] = len; + int startSeg = 0; + int xEnd; + for (int seg = 0; seg startSeg) { + // ERAN IFRAH + if(isLine) { + int ww = rcClient.Width(); + rcClient.left = x; + rcClient.right = rcClient.left + ww; + surface->PenColour(colourDivider); + surface->MoveTo(0, rcClient.top); + surface->LineTo(rcClient.right, rcClient.top); + xEnd = rcClient.right; + // END + } else if (IsArrowCharacter(s[startSeg])) { + bool upArrow = s[startSeg] == '\001'; + rcClient.left = x; + rcClient.right = rcClient.left + widthArrow; + if (draw) { + const int halfWidth = widthArrow / 2 - 3; + const int centreX = rcClient.left + widthArrow / 2 - 1; + const int centreY = (rcClient.top + rcClient.bottom) / 2; + surface->FillRectangle(rcClient, colourBG.allocated); + PRectangle rcClientInner(rcClient.left + 1, rcClient.top + 1, + rcClient.right - 2, rcClient.bottom - 1); + surface->FillRectangle(rcClientInner, colourUnSel.allocated); + + if (upArrow) { // Up arrow + Point pts[] = { + Point(centreX - halfWidth, centreY + halfWidth / 2), + Point(centreX + halfWidth, centreY + halfWidth / 2), + Point(centreX, centreY - halfWidth + halfWidth / 2), + }; + surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]), + colourBG.allocated, colourBG.allocated); + } else { // Down arrow + Point pts[] = { + Point(centreX - halfWidth, centreY - halfWidth / 2), + Point(centreX + halfWidth, centreY - halfWidth / 2), + Point(centreX, centreY + halfWidth - halfWidth / 2), + }; + surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]), + colourBG.allocated, colourBG.allocated); + } + } + xEnd = rcClient.right; + offsetMain = xEnd; + if (upArrow) { + rectUp = rcClient; + } else { + rectDown = rcClient; + } + } else if (IsTabCharacter(s[startSeg])) { + xEnd = NextTabPos(x); + } else { + // ERAN IFRAH + bool doxyHighlight = (s[startSeg] == '@' || s[startSeg] == '\\'); + xEnd = x + surface->WidthText(font, s + startSeg, endSeg - startSeg); + if (draw) + { + rcClient.left = x; + rcClient.right = xEnd; + if(doxyHighlight) { + surface->DrawTextTransparent(rcClient, font, ytext, + s+startSeg, endSeg - startSeg, + colourDoxyHighlight); + } else { + surface->DrawTextTransparent(rcClient, font, ytext, + s+startSeg, endSeg - startSeg, + highlight ? colourSel.allocated : colourUnSel.allocated); + } + } + // ERAN IFRAH - END + } + x = xEnd; + startSeg = endSeg; + } + } +} + +int CallTip::PaintContents(Surface *surfaceWindow, bool draw) { + PRectangle rcClientPos = wCallTip.GetClientPosition(); + PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left, + rcClientPos.bottom - rcClientPos.top); + PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1); + + // To make a nice small call tip window, it is only sized to fit most normal characters without accents + int ascent = surfaceWindow->Ascent(font) - surfaceWindow->InternalLeading(font); + + // For each line... + // Draw the definition in three parts: before highlight, highlighted, after highlight + int ytext = rcClient.top + ascent + 1; + rcClient.bottom = ytext + surfaceWindow->Descent(font) + 1; + char *chunkVal = val; + bool moreChunks = true; + int maxWidth = 0; + + while (moreChunks) { + char *chunkEnd = strchr(chunkVal, '\n'); + if (chunkEnd == NULL) { + chunkEnd = chunkVal + strlen(chunkVal); + moreChunks = false; + } + int chunkOffset = chunkVal - val; + int chunkLength = chunkEnd - chunkVal; + int chunkEndOffset = chunkOffset + chunkLength; + int thisStartHighlight = Platform::Maximum(startHighlight, chunkOffset); + thisStartHighlight = Platform::Minimum(thisStartHighlight, chunkEndOffset); + thisStartHighlight -= chunkOffset; + int thisEndHighlight = Platform::Maximum(endHighlight, chunkOffset); + thisEndHighlight = Platform::Minimum(thisEndHighlight, chunkEndOffset); + thisEndHighlight -= chunkOffset; + rcClient.top = ytext - ascent - 1; + + int x = insetX; // start each line at this inset + + DrawChunk(surfaceWindow, x, chunkVal, 0, thisStartHighlight, + ytext, rcClient, false, draw); + DrawChunk(surfaceWindow, x, chunkVal, thisStartHighlight, thisEndHighlight, + ytext, rcClient, true, draw); + DrawChunk(surfaceWindow, x, chunkVal, thisEndHighlight, chunkLength, + ytext, rcClient, false, draw); + + chunkVal = chunkEnd + 1; + ytext += lineHeight; + rcClient.bottom += lineHeight; + maxWidth = Platform::Maximum(maxWidth, x); + } + return maxWidth; +} + +void CallTip::PaintCT(Surface *surfaceWindow) { + if (!val) + return; + PRectangle rcClientPos = wCallTip.GetClientPosition(); + PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left, + rcClientPos.bottom - rcClientPos.top); + PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1); + + surfaceWindow->FillRectangle(rcClient, colourBG.allocated); + + offsetMain = insetX; // initial alignment assuming no arrows + PaintContents(surfaceWindow, true); + + // OSX doesn't put borders on "help tags" + // Draw a raised border around the edges of the window + surfaceWindow->MoveTo(0, rcClientSize.bottom - 1); + surfaceWindow->PenColour(colourShade.allocated); + surfaceWindow->LineTo(rcClientSize.right - 1, rcClientSize.bottom - 1); + surfaceWindow->LineTo(rcClientSize.right - 1, 0); + surfaceWindow->PenColour(colourShade.allocated); + surfaceWindow->LineTo(0, 0); + surfaceWindow->LineTo(0, rcClientSize.bottom - 1); +} + +void CallTip::MouseClick(Point pt) { + clickPlace = 0; + if (rectUp.Contains(pt)) + clickPlace = 1; + if (rectDown.Contains(pt)) + clickPlace = 2; +} + +PRectangle CallTip::CallTipStart(int pos, Point pt, const char *defn, + const char *faceName, int size, + int codePage_, int characterSet, Window &wParent) { + clickPlace = 0; + delete []val; + val = 0; + val = new char[strlen(defn) + 1]; + strcpy(val, defn); + codePage = codePage_; + Surface *surfaceMeasure = Surface::Allocate(); + if (!surfaceMeasure) + return PRectangle(); + surfaceMeasure->Init(wParent.GetID()); + surfaceMeasure->SetUnicodeMode(SC_CP_UTF8 == codePage); + surfaceMeasure->SetDBCSMode(codePage); + startHighlight = 0; + endHighlight = 0; + inCallTipMode = true; + posStartCallTip = pos; + int deviceHeight = surfaceMeasure->DeviceHeightFont(size); + font.Create(faceName, characterSet, deviceHeight, false, false); + // Look for multiple lines in the text + // Only support \n here - simply means container must avoid \r! + int numLines = 1; + const char *newline; + const char *look = val; + rectUp = PRectangle(0,0,0,0); + rectDown = PRectangle(0,0,0,0); + offsetMain = insetX; // changed to right edge of any arrows + int width = PaintContents(surfaceMeasure, false) + insetX; + while ((newline = strchr(look, '\n')) != NULL) { + look = newline + 1; + numLines++; + } + lineHeight = surfaceMeasure->Height(font); + + // Extra line for border and an empty line at top and bottom. The returned + // rectangle is aligned to the right edge of the last arrow encountered in + // the tip text, else to the tip text left edge. + int height = lineHeight * numLines - surfaceMeasure->InternalLeading(font) + 2 + 2; + delete surfaceMeasure; + return PRectangle(pt.x - offsetMain, pt.y + 1, pt.x + width - offsetMain, pt.y + 1 + height); +} + +void CallTip::CallTipCancel() { + inCallTipMode = false; + if (wCallTip.Created()) { + wCallTip.Destroy(); + } +} + +void CallTip::SetHighlight(int start, int end) { + // Avoid flashing by checking something has really changed + if ((start != startHighlight) || (end != endHighlight)) { + startHighlight = start; + endHighlight = end; + if (wCallTip.Created()) { + wCallTip.InvalidateAll(); + } + } +} + +// Set the tab size (sizes > 0 enable the use of tabs). This also enables the +// use of the STYLE_CALLTIP. +void CallTip::SetTabSize(int tabSz) { + tabSize = tabSz; + useStyleCallTip = true; +} + +// It might be better to have two access functions for this and to use +// them for all settings of colours. +void CallTip::SetForeBack(const ColourPair &fore, const ColourPair &back) { + colourBG = back; + colourUnSel = fore; +} diff --git a/sdk/wxscintilla/src/scintilla/src/CallTip.h b/sdk/wxscintilla/src/scintilla/src/CallTip.h new file mode 100644 index 0000000..b01f0a6 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CallTip.h @@ -0,0 +1,91 @@ +// Scintilla source code edit control +/** @file CallTip.h + ** Interface to the call tip control. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef CALLTIP_H +#define CALLTIP_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ +class CallTip { + int startHighlight; // character offset to start and... + int endHighlight; // ...end of highlighted text + char *val; + Font font; + PRectangle rectUp; // rectangle of last up angle in the tip + PRectangle rectDown; // rectangle of last down arrow in the tip + int lineHeight; // vertical line spacing + int offsetMain; // The alignment point of the call tip + int tabSize; // Tab size in pixels, <=0 no TAB expand + bool useStyleCallTip; // if true, STYLE_CALLTIP should be used + + // Private so CallTip objects can not be copied + CallTip(const CallTip &); + CallTip &operator=(const CallTip &); + void DrawChunk(Surface *surface, int &x, const char *s, + int posStart, int posEnd, int ytext, PRectangle rcClient, + bool highlight, bool draw); + int PaintContents(Surface *surfaceWindow, bool draw); + bool IsTabCharacter(char c) const; + int NextTabPos(int x); + +public: + Window wCallTip; + Window wDraw; + bool inCallTipMode; + int posStartCallTip; + ColourPair colourBG; + ColourPair colourUnSel; + ColourPair colourSel; + ColourPair colourShade; + ColourPair colourLight; + // ERAN IFRAH + ColourAllocated colourDivider; + ColourAllocated colourDoxyHighlight; + // ERAN IFRAH - END + int codePage; + int clickPlace; + + CallTip(); + ~CallTip(); + + /// Claim or accept palette entries for the colours required to paint a calltip. + void RefreshColourPalette(Palette &pal, bool want); + + void PaintCT(Surface *surfaceWindow); + + void MouseClick(Point pt); + + /// Setup the calltip and return a rectangle of the area required. + PRectangle CallTipStart(int pos, Point pt, const char *defn, + const char *faceName, int size, int codePage_, + int characterSet, Window &wParent); + + void CallTipCancel(); + + /// Set a range of characters to be displayed in a highlight style. + /// Commonly used to highlight the current parameter. + void SetHighlight(int start, int end); + + /// Set the tab size in pixels for the call tip. 0 or -ve means no tab expand. + void SetTabSize(int tabSz); + + /// Used to determine which STYLE_xxxx to use for call tip information + bool UseStyleCallTip() const { return useStyleCallTip;} + + // Modify foreground and background colours + void SetForeBack(const ColourPair &fore, const ColourPair &back); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/CellBuffer.cxx b/sdk/wxscintilla/src/scintilla/src/CellBuffer.cxx new file mode 100644 index 0000000..6c116ba --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CellBuffer.cxx @@ -0,0 +1,656 @@ +// Scintilla source code edit control +/** @file CellBuffer.cxx + ** Manages a buffer of cells. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include "Platform.h" + +#include "Scintilla.h" +#include "SplitVector.h" +#include "Partitioning.h" +#include "CellBuffer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +LineVector::LineVector() : starts(256), perLine(0) { + Init(); +} + +LineVector::~LineVector() { + starts.DeleteAll(); +} + +void LineVector::Init() { + starts.DeleteAll(); + if (perLine) { + perLine->Init(); + } +} + +void LineVector::SetPerLine(PerLine *pl) { + perLine = pl; +} + +void LineVector::InsertText(int line, int delta) { + starts.InsertText(line, delta); +} + +void LineVector::InsertLine(int line, int position, bool lineStart) { + starts.InsertPartition(line, position); + if (perLine) { + if ((line > 0) && lineStart) + line--; + perLine->InsertLine(line); + } +} + +void LineVector::SetLineStart(int line, int position) { + starts.SetPartitionStartPosition(line, position); +} + +void LineVector::RemoveLine(int line) { + starts.RemovePartition(line); + if (perLine) { + perLine->RemoveLine(line); + } +} + +int LineVector::LineFromPosition(int pos) const { + return starts.PartitionFromPosition(pos); +} + +Action::Action() { + at = startAction; + position = 0; + data = 0; + lenData = 0; + mayCoalesce = false; +} + +Action::~Action() { + Destroy(); +} + +void Action::Create(actionType at_, int position_, char *data_, int lenData_, bool mayCoalesce_) { + delete []data; + position = position_; + at = at_; + data = data_; + lenData = lenData_; + mayCoalesce = mayCoalesce_; +} + +void Action::Destroy() { + delete []data; + data = 0; +} + +void Action::Grab(Action *source) { + delete []data; + + position = source->position; + at = source->at; + data = source->data; + lenData = source->lenData; + mayCoalesce = source->mayCoalesce; + + // Ownership of source data transferred to this + source->position = 0; + source->at = startAction; + source->data = 0; + source->lenData = 0; + source->mayCoalesce = true; +} + +// The undo history stores a sequence of user operations that represent the user's view of the +// commands executed on the text. +// Each user operation contains a sequence of text insertion and text deletion actions. +// All the user operations are stored in a list of individual actions with 'start' actions used +// as delimiters between user operations. +// Initially there is one start action in the history. +// As each action is performed, it is recorded in the history. The action may either become +// part of the current user operation or may start a new user operation. If it is to be part of the +// current operation, then it overwrites the current last action. If it is to be part of a new +// operation, it is appended after the current last action. +// After writing the new action, a new start action is appended at the end of the history. +// The decision of whether to start a new user operation is based upon two factors. If a +// compound operation has been explicitly started by calling BeginUndoAction and no matching +// EndUndoAction (these calls nest) has been called, then the action is coalesced into the current +// operation. If there is no outstanding BeginUndoAction call then a new operation is started +// unless it looks as if the new action is caused by the user typing or deleting a stream of text. +// Sequences that look like typing or deletion are coalesced into a single user operation. + +UndoHistory::UndoHistory() { + + lenActions = 100; + actions = new Action[lenActions]; + maxAction = 0; + currentAction = 0; + undoSequenceDepth = 0; + savePoint = 0; + + actions[currentAction].Create(startAction); +} + +UndoHistory::~UndoHistory() { + delete []actions; + actions = 0; +} + +void UndoHistory::EnsureUndoRoom() { + // Have to test that there is room for 2 more actions in the array + // as two actions may be created by the calling function + if (currentAction >= (lenActions - 2)) { + // Run out of undo nodes so extend the array + int lenActionsNew = lenActions * 2; + Action *actionsNew = new Action[lenActionsNew]; + for (int act = 0; act <= currentAction; act++) + actionsNew[act].Grab(&actions[act]); + delete []actions; + lenActions = lenActionsNew; + actions = actionsNew; + } +} + +void UndoHistory::AppendAction(actionType at, int position, char *data, int lengthData, + bool &startSequence, bool mayCoalesce) { + EnsureUndoRoom(); + //Platform::DebugPrintf("%% %d action %d %d %d\n", at, position, lengthData, currentAction); + //Platform::DebugPrintf("^ %d action %d %d\n", actions[currentAction - 1].at, + // actions[currentAction - 1].position, actions[currentAction - 1].lenData); + if (currentAction < savePoint) { + savePoint = -1; + } + int oldCurrentAction = currentAction; + if (currentAction >= 1) { + if (0 == undoSequenceDepth) { + // Top level actions may not always be coalesced + int targetAct = -1; + const Action *actPrevious = &(actions[currentAction + targetAct]); + // Container actions may forward the coalesce state of Scintilla Actions. + while ((actPrevious->at == containerAction) && actPrevious->mayCoalesce) { + targetAct--; + actPrevious = &(actions[currentAction + targetAct]); + } + // See if current action can be coalesced into previous action + // Will work if both are inserts or deletes and position is same + if (currentAction == savePoint) { + currentAction++; + } else if (!actions[currentAction].mayCoalesce) { + // Not allowed to coalesce if this set + currentAction++; + } else if (!mayCoalesce || !actPrevious->mayCoalesce) { + currentAction++; + } else if (at == containerAction || actions[currentAction].at == containerAction) { + ; // A coalescible containerAction + } else if ((at != actPrevious->at) && (actPrevious->at != startAction)) { + currentAction++; + } else if ((at == insertAction) && + (position != (actPrevious->position + actPrevious->lenData))) { + // Insertions must be immediately after to coalesce + currentAction++; + } else if (at == removeAction) { + if ((lengthData == 1) || (lengthData == 2)){ + if ((position + lengthData) == actPrevious->position) { + ; // Backspace -> OK + } else if (position == actPrevious->position) { + ; // Delete -> OK + } else { + // Removals must be at same position to coalesce + currentAction++; + } + } else { + // Removals must be of one character to coalesce + currentAction++; + } + } else { + // Action coalesced. + } + + } else { + // Actions not at top level are always coalesced unless this is after return to top level + if (!actions[currentAction].mayCoalesce) + currentAction++; + } + } else { + currentAction++; + } + startSequence = oldCurrentAction != currentAction; + actions[currentAction].Create(at, position, data, lengthData, mayCoalesce); + currentAction++; + actions[currentAction].Create(startAction); + maxAction = currentAction; +} + +void UndoHistory::BeginUndoAction() { + EnsureUndoRoom(); + if (undoSequenceDepth == 0) { + if (actions[currentAction].at != startAction) { + currentAction++; + actions[currentAction].Create(startAction); + maxAction = currentAction; + } + actions[currentAction].mayCoalesce = false; + } + undoSequenceDepth++; +} + +void UndoHistory::EndUndoAction() { + PLATFORM_ASSERT(undoSequenceDepth > 0); + EnsureUndoRoom(); + undoSequenceDepth--; + if (0 == undoSequenceDepth) { + if (actions[currentAction].at != startAction) { + currentAction++; + actions[currentAction].Create(startAction); + maxAction = currentAction; + } + actions[currentAction].mayCoalesce = false; + } +} + +void UndoHistory::DropUndoSequence() { + undoSequenceDepth = 0; +} + +void UndoHistory::DeleteUndoHistory() { + for (int i = 1; i < maxAction; i++) + actions[i].Destroy(); + maxAction = 0; + currentAction = 0; + actions[currentAction].Create(startAction); + savePoint = 0; +} + +void UndoHistory::SetSavePoint() { + savePoint = currentAction; +} + +bool UndoHistory::IsSavePoint() const { + return savePoint == currentAction; +} + +bool UndoHistory::CanUndo() const { + return (currentAction > 0) && (maxAction > 0); +} + +int UndoHistory::StartUndo() { + // Drop any trailing startAction + if (actions[currentAction].at == startAction && currentAction > 0) + currentAction--; + + // Count the steps in this action + int act = currentAction; + while (actions[act].at != startAction && act > 0) { + act--; + } + return currentAction - act; +} + +const Action &UndoHistory::GetUndoStep() const { + return actions[currentAction]; +} + +void UndoHistory::CompletedUndoStep() { + currentAction--; +} + +bool UndoHistory::CanRedo() const { + return maxAction > currentAction; +} + +int UndoHistory::StartRedo() { + // Drop any leading startAction + if (actions[currentAction].at == startAction && currentAction < maxAction) + currentAction++; + + // Count the steps in this action + int act = currentAction; + while (actions[act].at != startAction && act < maxAction) { + act++; + } + return act - currentAction; +} + +const Action &UndoHistory::GetRedoStep() const { + return actions[currentAction]; +} + +void UndoHistory::CompletedRedoStep() { + currentAction++; +} + +CellBuffer::CellBuffer() { + readOnly = false; + collectingUndo = true; +} + +CellBuffer::~CellBuffer() { +} + +char CellBuffer::CharAt(int position) const { + return substance.ValueAt(position); +} + +void CellBuffer::GetCharRange(char *buffer, int position, int lengthRetrieve) const { + if (lengthRetrieve < 0) + return; + if (position < 0) + return; + if ((position + lengthRetrieve) > substance.Length()) { + Platform::DebugPrintf("Bad GetCharRange %d for %d of %d\n", position, + lengthRetrieve, substance.Length()); + return; + } + + for (int i=0; i((curVal & ~mask) | styleValue)); + return true; + } else { + return false; + } +} + +bool CellBuffer::SetStyleFor(int position, int lengthStyle, char styleValue, char mask) { + bool changed = false; + PLATFORM_ASSERT(lengthStyle == 0 || + (lengthStyle > 0 && lengthStyle + position <= style.Length())); + while (lengthStyle--) { + char curVal = style.ValueAt(position); + if ((curVal & mask) != styleValue) { + style.SetValueAt(position, static_cast((curVal & ~mask) | styleValue)); + changed = true; + } + position++; + } + return changed; +} + +// The char* returned is to an allocation owned by the undo history +const char *CellBuffer::DeleteChars(int position, int deleteLength, bool &startSequence) { + // InsertString and DeleteChars are the bottleneck though which all changes occur + PLATFORM_ASSERT(deleteLength > 0); + char *data = 0; + if (!readOnly) { + if (collectingUndo) { + // Save into the undo/redo stack, but only the characters - not the formatting + data = new char[deleteLength]; + for (int i = 0; i < deleteLength; i++) { + data[i] = substance.ValueAt(position + i); + } + uh.AppendAction(removeAction, position, data, deleteLength, startSequence); + } + + BasicDeleteChars(position, deleteLength); + } + return data; +} + +int CellBuffer::Length() const { + return substance.Length(); +} + +void CellBuffer::Allocate(int newSize) { + substance.ReAllocate(newSize); + style.ReAllocate(newSize); +} + +void CellBuffer::SetPerLine(PerLine *pl) { + lv.SetPerLine(pl); +} + +int CellBuffer::Lines() const { + return lv.Lines(); +} + +int CellBuffer::LineStart(int line) const { + if (line < 0) + return 0; + else if (line >= Lines()) + return Length(); + else + return lv.LineStart(line); +} + +bool CellBuffer::IsReadOnly() const { + return readOnly; +} + +void CellBuffer::SetReadOnly(bool set) { + readOnly = set; +} + +void CellBuffer::SetSavePoint() { + uh.SetSavePoint(); +} + +bool CellBuffer::IsSavePoint() { + return uh.IsSavePoint(); +} + +// Without undo + +void CellBuffer::InsertLine(int line, int position, bool lineStart) { + lv.InsertLine(line, position, lineStart); +} + +void CellBuffer::RemoveLine(int line) { + lv.RemoveLine(line); +} + +void CellBuffer::BasicInsertString(int position, const char *s, int insertLength) { + if (insertLength == 0) + return; + PLATFORM_ASSERT(insertLength > 0); + + substance.InsertFromArray(position, s, 0, insertLength); + style.InsertValue(position, insertLength, 0); + + int lineInsert = lv.LineFromPosition(position) + 1; + bool atLineStart = lv.LineStart(lineInsert-1) == position; + // Point all the lines after the insertion point further along in the buffer + lv.InsertText(lineInsert-1, insertLength); + char chPrev = substance.ValueAt(position - 1); + char chAfter = substance.ValueAt(position + insertLength); + if (chPrev == '\r' && chAfter == '\n') { + // Splitting up a crlf pair at position + InsertLine(lineInsert, position, false); + lineInsert++; + } + char ch = ' '; + for (int i = 0; i < insertLength; i++) { + ch = s[i]; + if (ch == '\r') { + InsertLine(lineInsert, (position + i) + 1, atLineStart); + lineInsert++; + } else if (ch == '\n') { + if (chPrev == '\r') { + // Patch up what was end of line + lv.SetLineStart(lineInsert - 1, (position + i) + 1); + } else { + InsertLine(lineInsert, (position + i) + 1, atLineStart); + lineInsert++; + } + } + chPrev = ch; + } + // Joining two lines where last insertion is cr and following substance starts with lf + if (chAfter == '\n') { + if (ch == '\r') { + // End of line already in buffer so drop the newly created one + RemoveLine(lineInsert - 1); + } + } +} + +void CellBuffer::BasicDeleteChars(int position, int deleteLength) { + if (deleteLength == 0) + return; + + if ((position == 0) && (deleteLength == substance.Length())) { + // If whole buffer is being deleted, faster to reinitialise lines data + // than to delete each line. + lv.Init(); + } else { + // Have to fix up line positions before doing deletion as looking at text in buffer + // to work out which lines have been removed + + int lineRemove = lv.LineFromPosition(position) + 1; + lv.InsertText(lineRemove-1, - (deleteLength)); + char chPrev = substance.ValueAt(position - 1); + char chBefore = chPrev; + char chNext = substance.ValueAt(position); + bool ignoreNL = false; + if (chPrev == '\r' && chNext == '\n') { + // Move back one + lv.SetLineStart(lineRemove, position); + lineRemove++; + ignoreNL = true; // First \n is not real deletion + } + + char ch = chNext; + for (int i = 0; i < deleteLength; i++) { + chNext = substance.ValueAt(position + i + 1); + if (ch == '\r') { + if (chNext != '\n') { + RemoveLine(lineRemove); + } + } else if (ch == '\n') { + if (ignoreNL) { + ignoreNL = false; // Further \n are real deletions + } else { + RemoveLine(lineRemove); + } + } + + ch = chNext; + } + // May have to fix up end if last deletion causes cr to be next to lf + // or removes one of a crlf pair + char chAfter = substance.ValueAt(position + deleteLength); + if (chBefore == '\r' && chAfter == '\n') { + // Using lineRemove-1 as cr ended line before start of deletion + RemoveLine(lineRemove - 1); + lv.SetLineStart(lineRemove - 1, position + 1); + } + } + substance.DeleteRange(position, deleteLength); + style.DeleteRange(position, deleteLength); +} + +bool CellBuffer::SetUndoCollection(bool collectUndo) { + collectingUndo = collectUndo; + uh.DropUndoSequence(); + return collectingUndo; +} + +bool CellBuffer::IsCollectingUndo() const { + return collectingUndo; +} + +void CellBuffer::BeginUndoAction() { + uh.BeginUndoAction(); +} + +void CellBuffer::EndUndoAction() { + uh.EndUndoAction(); +} + +void CellBuffer::AddUndoAction(int token, bool mayCoalesce) { + bool startSequence; + uh.AppendAction(containerAction, token, 0, 0, startSequence, mayCoalesce); +} + +void CellBuffer::DeleteUndoHistory() { + uh.DeleteUndoHistory(); +} + +bool CellBuffer::CanUndo() { + return uh.CanUndo(); +} + +int CellBuffer::StartUndo() { + return uh.StartUndo(); +} + +const Action &CellBuffer::GetUndoStep() const { + return uh.GetUndoStep(); +} + +void CellBuffer::PerformUndoStep() { + const Action &actionStep = uh.GetUndoStep(); + if (actionStep.at == insertAction) { + BasicDeleteChars(actionStep.position, actionStep.lenData); + } else if (actionStep.at == removeAction) { + BasicInsertString(actionStep.position, actionStep.data, actionStep.lenData); + } + uh.CompletedUndoStep(); +} + +bool CellBuffer::CanRedo() { + return uh.CanRedo(); +} + +int CellBuffer::StartRedo() { + return uh.StartRedo(); +} + +const Action &CellBuffer::GetRedoStep() const { + return uh.GetRedoStep(); +} + +void CellBuffer::PerformRedoStep() { + const Action &actionStep = uh.GetRedoStep(); + if (actionStep.at == insertAction) { + BasicInsertString(actionStep.position, actionStep.data, actionStep.lenData); + } else if (actionStep.at == removeAction) { + BasicDeleteChars(actionStep.position, actionStep.lenData); + } + uh.CompletedRedoStep(); +} + diff --git a/sdk/wxscintilla/src/scintilla/src/CellBuffer.h b/sdk/wxscintilla/src/scintilla/src/CellBuffer.h new file mode 100644 index 0000000..78f586e --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CellBuffer.h @@ -0,0 +1,208 @@ +// Scintilla source code edit control +/** @file CellBuffer.h + ** Manages the text of the document. + **/ +// Copyright 1998-2004 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef CELLBUFFER_H +#define CELLBUFFER_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +// Interface to per-line data that wants to see each line insertion and deletion +class PerLine { +public: + virtual ~PerLine() {} + virtual void Init()=0; + virtual void InsertLine(int)=0; + virtual void RemoveLine(int)=0; +}; + +/** + * The line vector contains information about each of the lines in a cell buffer. + */ +class LineVector { + + Partitioning starts; + PerLine *perLine; + +public: + + LineVector(); + ~LineVector(); + void Init(); + void SetPerLine(PerLine *pl); + + void InsertText(int line, int delta); + void InsertLine(int line, int position, bool lineStart); + void SetLineStart(int line, int position); + void RemoveLine(int line); + int Lines() const { + return starts.Partitions(); + } + int LineFromPosition(int pos) const; + int LineStart(int line) const { + return starts.PositionFromPartition(line); + } + + int MarkValue(int line); + int AddMark(int line, int marker); + void MergeMarkers(int pos); + void DeleteMark(int line, int markerNum, bool all); + void DeleteMarkFromHandle(int markerHandle); + int LineFromHandle(int markerHandle); + + void ClearLevels(); + int SetLevel(int line, int level); + int GetLevel(int line); + + int SetLineState(int line, int state); + int GetLineState(int line); + int GetMaxLineState(); + +}; + +enum actionType { insertAction, removeAction, startAction, containerAction }; + +/** + * Actions are used to store all the information required to perform one undo/redo step. + */ +class Action { +public: + actionType at; + int position; + char *data; + int lenData; + bool mayCoalesce; + + Action(); + ~Action(); + void Create(actionType at_, int position_=0, char *data_=0, int lenData_=0, bool mayCoalesce_=true); + void Destroy(); + void Grab(Action *source); +}; + +/** + * + */ +class UndoHistory { + Action *actions; + int lenActions; + int maxAction; + int currentAction; + int undoSequenceDepth; + int savePoint; + + void EnsureUndoRoom(); + +public: + UndoHistory(); + ~UndoHistory(); + + void AppendAction(actionType at, int position, char *data, int length, bool &startSequence, bool mayCoalesce=true); + + void BeginUndoAction(); + void EndUndoAction(); + void DropUndoSequence(); + void DeleteUndoHistory(); + + /// The save point is a marker in the undo stack where the container has stated that + /// the buffer was saved. Undo and redo can move over the save point. + void SetSavePoint(); + bool IsSavePoint() const; + + /// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is + /// called that many times. Similarly for redo. + bool CanUndo() const; + int StartUndo(); + const Action &GetUndoStep() const; + void CompletedUndoStep(); + bool CanRedo() const; + int StartRedo(); + const Action &GetRedoStep() const; + void CompletedRedoStep(); +}; + +/** + * Holder for an expandable array of characters that supports undo and line markers. + * Based on article "Data Structures in a Bit-Mapped Text Editor" + * by Wilfred J. Hansen, Byte January 1987, page 183. + */ +class CellBuffer { +private: + SplitVector substance; + SplitVector style; + bool readOnly; + + bool collectingUndo; + UndoHistory uh; + + LineVector lv; + +public: + + CellBuffer(); + ~CellBuffer(); + + /// Retrieving positions outside the range of the buffer works and returns 0 + char CharAt(int position) const; + void GetCharRange(char *buffer, int position, int lengthRetrieve) const; + char StyleAt(int position) const; + const char *BufferPointer(); + + int Length() const; + void Allocate(int newSize); + void SetPerLine(PerLine *pl); + int Lines() const; + int LineStart(int line) const; + int LineFromPosition(int pos) const { return lv.LineFromPosition(pos); } + void InsertLine(int line, int position, bool lineStart); + void RemoveLine(int line); + const char *InsertString(int position, const char *s, int insertLength, bool &startSequence); + + /// Setting styles for positions outside the range of the buffer is safe and has no effect. + /// @return true if the style of a character is changed. + bool SetStyleAt(int position, char styleValue, char mask='\377'); + bool SetStyleFor(int position, int length, char styleValue, char mask); + + const char *DeleteChars(int position, int deleteLength, bool &startSequence); + + bool IsReadOnly() const; + void SetReadOnly(bool set); + + /// The save point is a marker in the undo stack where the container has stated that + /// the buffer was saved. Undo and redo can move over the save point. + void SetSavePoint(); + bool IsSavePoint(); + + /// Actions without undo + void BasicInsertString(int position, const char *s, int insertLength); + void BasicDeleteChars(int position, int deleteLength); + + bool SetUndoCollection(bool collectUndo); + bool IsCollectingUndo() const; + void BeginUndoAction(); + void EndUndoAction(); + void AddUndoAction(int token, bool mayCoalesce); + void DeleteUndoHistory(); + + /// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is + /// called that many times. Similarly for redo. + bool CanUndo(); + int StartUndo(); + const Action &GetUndoStep() const; + void PerformUndoStep(); + bool CanRedo(); + int StartRedo(); + const Action &GetRedoStep() const; + void PerformRedoStep(); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/CharClassify.cxx b/sdk/wxscintilla/src/scintilla/src/CharClassify.cxx new file mode 100644 index 0000000..bbd25a0 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CharClassify.cxx @@ -0,0 +1,78 @@ +// Scintilla source code edit control +/** @file CharClassify.cxx + ** Character classifications used by Document and RESearch. + **/ +// Copyright 2006 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include + +#include "CharClassify.h" + +// Shut up annoying Visual C++ warnings: +#ifdef _MSC_VER +#pragma warning(disable: 4514) +#endif + +CharClassify::CharClassify() { + SetDefaultCharClasses(true); +} + +void CharClassify::SetDefaultCharClasses(bool includeWordClass) { + // Initialize all char classes to default values + for (int ch = 0; ch < 256; ch++) { + if (ch == '\r' || ch == '\n') + charClass[ch] = ccNewLine; + else if (ch < 0x20 || ch == ' ') + charClass[ch] = ccSpace; + else if (includeWordClass && (ch >= 0x80 || isalnum(ch) || ch == '_')) + charClass[ch] = ccWord; + else + charClass[ch] = ccPunctuation; + } +} + +void CharClassify::SetCharClasses(const unsigned char *chars, cc newCharClass) { + // Apply the newCharClass to the specifed chars + if (chars) { + while (*chars) { + charClass[*chars] = static_cast(newCharClass); + chars++; + } + } +} + +int CompareCaseInsensitive(const char *a, const char *b) { + while (*a && *b) { + if (*a != *b) { + char upperA = MakeUpperCase(*a); + char upperB = MakeUpperCase(*b); + if (upperA != upperB) + return upperA - upperB; + } + a++; + b++; + } + // Either *a or *b is nul + return *a - *b; +} + +int CompareNCaseInsensitive(const char *a, const char *b, size_t len) { + while (*a && *b && len) { + if (*a != *b) { + char upperA = MakeUpperCase(*a); + char upperB = MakeUpperCase(*b); + if (upperA != upperB) + return upperA - upperB; + } + a++; + b++; + len--; + } + if (len == 0) + return 0; + else + // Either *a or *b is nul + return *a - *b; +} diff --git a/sdk/wxscintilla/src/scintilla/src/CharClassify.h b/sdk/wxscintilla/src/scintilla/src/CharClassify.h new file mode 100644 index 0000000..d746fe0 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CharClassify.h @@ -0,0 +1,37 @@ +// Scintilla source code edit control +/** @file CharClassify.h + ** Character classifications used by Document and RESearch. + **/ +// Copyright 2006-2009 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef CHARCLASSIFY_H +#define CHARCLASSIFY_H + +class CharClassify { +public: + CharClassify(); + + enum cc { ccSpace, ccNewLine, ccWord, ccPunctuation }; + void SetDefaultCharClasses(bool includeWordClass); + void SetCharClasses(const unsigned char *chars, cc newCharClass); + cc GetClass(unsigned char ch) const { return static_cast(charClass[ch]);} + bool IsWord(unsigned char ch) const { return static_cast(charClass[ch]) == ccWord;} + +private: + enum { maxChar=256 }; + unsigned char charClass[maxChar]; // not type cc to save space +}; + +// These functions are implemented because each platform calls them something different. +int CompareCaseInsensitive(const char *a, const char *b); +int CompareNCaseInsensitive(const char *a, const char *b, size_t len); + +inline char MakeUpperCase(char ch) { + if (ch < 'a' || ch > 'z') + return ch; + else + return static_cast(ch - 'a' + 'A'); +} + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/CharacterSet.h b/sdk/wxscintilla/src/scintilla/src/CharacterSet.h new file mode 100644 index 0000000..9b88696 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/CharacterSet.h @@ -0,0 +1,59 @@ +// Scintilla source code edit control +/** @file CharacterSet.h + ** Encapsulates a set of characters. Used to test if a character is within a set. + **/ +// Copyright 2007 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +class CharacterSet { + int size; + bool valueAfter; + bool *bset; +public: + enum setBase { + setNone=0, + setLower=1, + setUpper=2, + setDigits=4, + setAlpha=setLower|setUpper, + setAlphaNum=setAlpha|setDigits + }; + CharacterSet(setBase base=setNone, const char *initialSet="", int size_=0x80, bool valueAfter_=false) { + size = size_; + valueAfter = valueAfter_; + bset = new bool[size]; + for (int i=0; i < size; i++) { + bset[i] = false; + } + AddString(initialSet); + if (base & setLower) + AddString("abcdefghijklmnopqrstuvwxyz"); + if (base & setUpper) + AddString("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + if (base & setDigits) + AddString("0123456789"); + } + ~CharacterSet() { + delete []bset; + bset = 0; + size = 0; + } + void Add(int val) { + PLATFORM_ASSERT(val >= 0); + PLATFORM_ASSERT(val < size); + bset[val] = true; + } + void AddString(const char *CharacterSet) { + for (const char *cp=CharacterSet; *cp; cp++) { + int val = static_cast(*cp); + PLATFORM_ASSERT(val >= 0); + PLATFORM_ASSERT(val < size); + bset[val] = true; + } + } + bool Contains(int val) const { + PLATFORM_ASSERT(val >= 0); + if (val < 0) return false; + return (val < size) ? bset[val] : valueAfter; + } +}; diff --git a/sdk/wxscintilla/src/scintilla/src/ContractionState.cxx b/sdk/wxscintilla/src/scintilla/src/ContractionState.cxx new file mode 100644 index 0000000..08de5cf --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/ContractionState.cxx @@ -0,0 +1,251 @@ +// Scintilla source code edit control +/** @file ContractionState.cxx + ** Manages visibility of lines for folding and wrapping. + **/ +// Copyright 1998-2007 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include + +#include "Platform.h" + +#include "SplitVector.h" +#include "Partitioning.h" +#include "RunStyles.h" +#include "ContractionState.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +ContractionState::ContractionState() : visible(0), expanded(0), heights(0), displayLines(0), linesInDocument(1) { + //InsertLine(0); +} + +ContractionState::~ContractionState() { + Clear(); +} + +void ContractionState::EnsureData() { + if (OneToOne()) { + visible = new RunStyles(); + expanded = new RunStyles(); + heights = new RunStyles(); + displayLines = new Partitioning(4); + InsertLines(0, linesInDocument); + } +} + +void ContractionState::Clear() { + delete visible; + visible = 0; + delete expanded; + expanded = 0; + delete heights; + heights = 0; + delete displayLines; + displayLines = 0; + linesInDocument = 1; +} + +int ContractionState::LinesInDoc() const { + if (OneToOne()) { + return linesInDocument; + } else { + return displayLines->Partitions() - 1; + } +} + +int ContractionState::LinesDisplayed() const { + if (OneToOne()) { + return linesInDocument; + } else { + return displayLines->PositionFromPartition(LinesInDoc()); + } +} + +int ContractionState::DisplayFromDoc(int lineDoc) const { + if (OneToOne()) { + return lineDoc; + } else { + if (lineDoc > displayLines->Partitions()) + lineDoc = displayLines->Partitions(); + return displayLines->PositionFromPartition(lineDoc); + } +} + +int ContractionState::DocFromDisplay(int lineDisplay) const { + if (OneToOne()) { + return lineDisplay; + } else { + if (lineDisplay <= 0) { + return 0; + } + if (lineDisplay > LinesDisplayed()) { + return displayLines->PartitionFromPosition(LinesDisplayed()); + } + int lineDoc = displayLines->PartitionFromPosition(lineDisplay); + PLATFORM_ASSERT(GetVisible(lineDoc)); + return lineDoc; + } +} + +void ContractionState::InsertLine(int lineDoc) { + if (OneToOne()) { + linesInDocument++; + } else { + visible->InsertSpace(lineDoc, 1); + visible->SetValueAt(lineDoc, 1); + expanded->InsertSpace(lineDoc, 1); + expanded->SetValueAt(lineDoc, 1); + heights->InsertSpace(lineDoc, 1); + heights->SetValueAt(lineDoc, 1); + int lineDisplay = DisplayFromDoc(lineDoc); + displayLines->InsertPartition(lineDoc, lineDisplay); + displayLines->InsertText(lineDoc, 1); + } +} + +void ContractionState::InsertLines(int lineDoc, int lineCount) { + for (int l = 0; l < lineCount; l++) { + InsertLine(lineDoc + l); + } + Check(); +} + +void ContractionState::DeleteLine(int lineDoc) { + if (OneToOne()) { + linesInDocument--; + } else { + if (GetVisible(lineDoc)) { + displayLines->InsertText(lineDoc, -heights->ValueAt(lineDoc)); + } + displayLines->RemovePartition(lineDoc); + visible->DeleteRange(lineDoc, 1); + expanded->DeleteRange(lineDoc, 1); + heights->DeleteRange(lineDoc, 1); + } +} + +void ContractionState::DeleteLines(int lineDoc, int lineCount) { + for (int l = 0; l < lineCount; l++) { + DeleteLine(lineDoc); + } + Check(); +} + +bool ContractionState::GetVisible(int lineDoc) const { + if (OneToOne()) { + return true; + } else { + if (lineDoc >= visible->Length()) + return true; + return visible->ValueAt(lineDoc) == 1; + } +} + +bool ContractionState::SetVisible(int lineDocStart, int lineDocEnd, bool visible_) { + if (OneToOne() && visible_) { + return false; + } else { + EnsureData(); + int delta = 0; + Check(); + if ((lineDocStart <= lineDocEnd) && (lineDocStart >= 0) && (lineDocEnd < LinesInDoc())) { + for (int line = lineDocStart; line <= lineDocEnd; line++) { + if (GetVisible(line) != visible_) { + int difference = visible_ ? heights->ValueAt(line) : -heights->ValueAt(line); + visible->SetValueAt(line, visible_ ? 1 : 0); + displayLines->InsertText(line, difference); + delta += difference; + } + } + } else { + return false; + } + Check(); + return delta != 0; + } +} + +bool ContractionState::GetExpanded(int lineDoc) const { + if (OneToOne()) { + return true; + } else { + Check(); + return expanded->ValueAt(lineDoc) == 1; + } +} + +bool ContractionState::SetExpanded(int lineDoc, bool expanded_) { + if (OneToOne() && expanded_) { + return false; + } else { + EnsureData(); + if (expanded_ != (expanded->ValueAt(lineDoc) == 1)) { + expanded->SetValueAt(lineDoc, expanded_ ? 1 : 0); + Check(); + return true; + } else { + Check(); + return false; + } + } +} + +int ContractionState::GetHeight(int lineDoc) const { + if (OneToOne()) { + return 1; + } else { + return heights->ValueAt(lineDoc); + } +} + +// Set the number of display lines needed for this line. +// Return true if this is a change. +bool ContractionState::SetHeight(int lineDoc, int height) { + if (OneToOne() && (height == 1)) { + return false; + } else { + EnsureData(); + if (GetHeight(lineDoc) != height) { + if (GetVisible(lineDoc)) { + displayLines->InsertText(lineDoc, height - GetHeight(lineDoc)); + } + heights->SetValueAt(lineDoc, height); + Check(); + return true; + } else { + Check(); + return false; + } + } +} + +void ContractionState::ShowAll() { + int lines = LinesInDoc(); + Clear(); + linesInDocument = lines; +} + +// Debugging checks + +void ContractionState::Check() const { +#ifdef CHECK_CORRECTNESS + for (int vline = 0;vline < LinesDisplayed(); vline++) { + const int lineDoc = DocFromDisplay(vline); + PLATFORM_ASSERT(GetVisible(lineDoc)); + } + for (int lineDoc = 0;lineDoc < LinesInDoc(); lineDoc++) { + const int displayThis = DisplayFromDoc(lineDoc); + const int displayNext = DisplayFromDoc(lineDoc + 1); + const int height = displayNext - displayThis; + PLATFORM_ASSERT(height >= 0); + if (GetVisible(lineDoc)) { + PLATFORM_ASSERT(GetHeight(lineDoc) == height); + } else { + PLATFORM_ASSERT(0 == height); + } + } +#endif +} diff --git a/sdk/wxscintilla/src/scintilla/src/ContractionState.h b/sdk/wxscintilla/src/scintilla/src/ContractionState.h new file mode 100644 index 0000000..ba62975 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/ContractionState.h @@ -0,0 +1,66 @@ +// Scintilla source code edit control +/** @file ContractionState.h + ** Manages visibility of lines for folding and wrapping. + **/ +// Copyright 1998-2007 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef CONTRACTIONSTATE_H +#define CONTRACTIONSTATE_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ +class ContractionState { + // These contain 1 element for every document line. + RunStyles *visible; + RunStyles *expanded; + RunStyles *heights; + Partitioning *displayLines; + int linesInDocument; + + void EnsureData(); + + bool OneToOne() const { + // True when each document line is exactly one display line so need for + // complex data structures. + return visible == 0; + } + +public: + ContractionState(); + virtual ~ContractionState(); + + void Clear(); + + int LinesInDoc() const; + int LinesDisplayed() const; + int DisplayFromDoc(int lineDoc) const; + int DocFromDisplay(int lineDisplay) const; + + void InsertLine(int lineDoc); + void InsertLines(int lineDoc, int lineCount); + void DeleteLine(int lineDoc); + void DeleteLines(int lineDoc, int lineCount); + + bool GetVisible(int lineDoc) const; + bool SetVisible(int lineDocStart, int lineDocEnd, bool visible); + + bool GetExpanded(int lineDoc) const; + bool SetExpanded(int lineDoc, bool expanded); + + int GetHeight(int lineDoc) const; + bool SetHeight(int lineDoc, int height); + + void ShowAll(); + void Check() const; +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/Decoration.cxx b/sdk/wxscintilla/src/scintilla/src/Decoration.cxx new file mode 100644 index 0000000..e4ac0e0 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Decoration.cxx @@ -0,0 +1,188 @@ +/** @file Decoration.cxx + ** Visual elements added over text. + **/ +// Copyright 1998-2007 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include "Platform.h" + +#include "Scintilla.h" +#include "SplitVector.h" +#include "Partitioning.h" +#include "RunStyles.h" +#include "Decoration.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +Decoration::Decoration(int indicator_) : next(0), indicator(indicator_) { +} + +Decoration::~Decoration() { +} + +bool Decoration::Empty() { + return rs.starts->Partitions() == 1; +} + +DecorationList::DecorationList() : currentIndicator(0), currentValue(1), current(0), + lengthDocument(0), root(0), clickNotified(false) { +} + +DecorationList::~DecorationList() { + Decoration *deco = root; + while (deco) { + Decoration *decoNext = deco->next; + delete deco; + deco = decoNext; + } + root = 0; + current = 0; +} + +Decoration *DecorationList::DecorationFromIndicator(int indicator) { + for (Decoration *deco=root; deco; deco = deco->next) { + if (deco->indicator == indicator) { + return deco; + } + } + return 0; +} + +Decoration *DecorationList::Create(int indicator, int length) { + currentIndicator = indicator; + Decoration *decoNew = new Decoration(indicator); + decoNew->rs.InsertSpace(0, length); + + Decoration *decoPrev = 0; + Decoration *deco = root; + + while (deco && (deco->indicator < indicator)) { + decoPrev = deco; + deco = deco->next; + } + if (decoPrev == 0) { + decoNew->next = root; + root = decoNew; + } else { + decoNew->next = deco; + decoPrev->next = decoNew; + } + return decoNew; +} + +void DecorationList::Delete(int indicator) { + Decoration *decoToDelete = 0; + if (root) { + if (root->indicator == indicator) { + decoToDelete = root; + root = root->next; + } else { + Decoration *deco=root; + while (deco->next && !decoToDelete) { + if (deco->next && deco->next->indicator == indicator) { + decoToDelete = deco->next; + deco->next = decoToDelete->next; + } else { + deco = deco->next; + } + } + } + } + if (decoToDelete) { + delete decoToDelete; + current = 0; + } +} + +void DecorationList::SetCurrentIndicator(int indicator) { + currentIndicator = indicator; + current = DecorationFromIndicator(indicator); + currentValue = 1; +} + +void DecorationList::SetCurrentValue(int value) { + currentValue = value ? value : 1; +} + +bool DecorationList::FillRange(int &position, int value, int &fillLength) { + if (!current) { + current = DecorationFromIndicator(currentIndicator); + if (!current) { + current = Create(currentIndicator, lengthDocument); + } + } + bool changed = current->rs.FillRange(position, value, fillLength); + if (current->Empty()) { + Delete(currentIndicator); + } + return changed; +} + +void DecorationList::InsertSpace(int position, int insertLength) { + lengthDocument += insertLength; + for (Decoration *deco=root; deco; deco = deco->next) { + deco->rs.InsertSpace(position, insertLength); + } +} + +void DecorationList::DeleteRange(int position, int deleteLength) { + lengthDocument -= deleteLength; + Decoration *deco; + for (deco=root; deco; deco = deco->next) { + deco->rs.DeleteRange(position, deleteLength); + } + DeleteAnyEmpty(); +} + +void DecorationList::DeleteAnyEmpty() { + Decoration *deco = root; + while (deco) { + if (deco->Empty()) { + Delete(deco->indicator); + deco = root; + } else { + deco = deco->next; + } + } +} + +int DecorationList::AllOnFor(int position) { + int mask = 0; + for (Decoration *deco=root; deco; deco = deco->next) { + if (deco->rs.ValueAt(position)) { + mask |= 1 << deco->indicator; + } + } + return mask; +} + +int DecorationList::ValueAt(int indicator, int position) { + Decoration *deco = DecorationFromIndicator(indicator); + if (deco) { + return deco->rs.ValueAt(position); + } + return 0; +} + +int DecorationList::Start(int indicator, int position) { + Decoration *deco = DecorationFromIndicator(indicator); + if (deco) { + return deco->rs.StartRun(position); + } + return 0; +} + +int DecorationList::End(int indicator, int position) { + Decoration *deco = DecorationFromIndicator(indicator); + if (deco) { + return deco->rs.EndRun(position); + } + return 0; +} diff --git a/sdk/wxscintilla/src/scintilla/src/Decoration.h b/sdk/wxscintilla/src/scintilla/src/Decoration.h new file mode 100644 index 0000000..fedff97 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Decoration.h @@ -0,0 +1,64 @@ +/** @file Decoration.h + ** Visual elements added over text. + **/ +// Copyright 1998-2007 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef DECORATION_H +#define DECORATION_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +class Decoration { +public: + Decoration *next; + RunStyles rs; + int indicator; + + Decoration(int indicator_); + ~Decoration(); + + bool Empty(); +}; + +class DecorationList { + int currentIndicator; + int currentValue; + Decoration *current; + int lengthDocument; + Decoration *DecorationFromIndicator(int indicator); + Decoration *Create(int indicator, int length); + void Delete(int indicator); + void DeleteAnyEmpty(); +public: + Decoration *root; + bool clickNotified; + + DecorationList(); + ~DecorationList(); + + void SetCurrentIndicator(int indicator); + int GetCurrentIndicator() const { return currentIndicator; } + + void SetCurrentValue(int value); + int GetCurrentValue() const { return currentValue; } + + // Returns true if some values may have changed + bool FillRange(int &position, int value, int &fillLength); + + void InsertSpace(int position, int insertLength); + void DeleteRange(int position, int deleteLength); + + int AllOnFor(int position); + int ValueAt(int indicator, int position); + int Start(int indicator, int position); + int End(int indicator, int position); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/Document.cxx b/sdk/wxscintilla/src/scintilla/src/Document.cxx new file mode 100644 index 0000000..fbaaaf2 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Document.cxx @@ -0,0 +1,1920 @@ +// Scintilla source code edit control +/** @file Document.cxx + ** Text document that handles notifications, DBCS, styling, words and end of line. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include +#include + +// With Borland C++ 5.5, including includes Windows.h leading to defining +// FindText to FindTextA which makes calls here to Document::FindText fail. +#ifdef __BORLANDC__ +#ifdef FindText +#undef FindText +#endif +#endif + +#include "Platform.h" + +#include "Scintilla.h" +#include "SplitVector.h" +#include "Partitioning.h" +#include "RunStyles.h" +#include "CellBuffer.h" +#include "PerLine.h" +#include "CharClassify.h" +#include "Decoration.h" +#include "Document.h" +#include "RESearch.h" +#include "UniConversion.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +// This is ASCII specific but is safe with chars >= 0x80 +static inline bool isspacechar(unsigned char ch) { + return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d)); +} + +static inline bool IsPunctuation(char ch) { + return isascii(ch) && ispunct(ch); +} + +static inline bool IsADigit(char ch) { + return isascii(ch) && isdigit(ch); +} + +static inline bool IsLowerCase(char ch) { + return isascii(ch) && islower(ch); +} + +static inline bool IsUpperCase(char ch) { + return isascii(ch) && isupper(ch); +} + +Document::Document() { + refCount = 0; +#ifdef unix + eolMode = SC_EOL_LF; +#else + eolMode = SC_EOL_CRLF; +#endif + dbcsCodePage = 0; + stylingBits = 5; + stylingBitsMask = 0x1F; + stylingMask = 0; + endStyled = 0; + styleClock = 0; + enteredModification = 0; + enteredStyling = 0; + enteredReadOnlyCount = 0; + tabInChars = 8; + indentInChars = 0; + actualIndentInChars = 8; + useTabs = true; + tabIndents = true; + backspaceUnindents = false; + watchers = 0; + lenWatchers = 0; + + matchesValid = false; + regex = 0; + + perLineData[ldMarkers] = new LineMarkers(); + perLineData[ldLevels] = new LineLevels(); + perLineData[ldState] = new LineState(); + perLineData[ldMargin] = new LineAnnotation(); + perLineData[ldAnnotation] = new LineAnnotation(); + + cb.SetPerLine(this); +} + +Document::~Document() { + for (int i = 0; i < lenWatchers; i++) { + watchers[i].watcher->NotifyDeleted(this, watchers[i].userData); + } + delete []watchers; + for (int j=0; jInit(); + } +} + +void Document::InsertLine(int line) { + for (int j=0; jInsertLine(line); + } +} + +void Document::RemoveLine(int line) { + for (int j=0; jRemoveLine(line); + } +} + +// Increase reference count and return its previous value. +int Document::AddRef() { + return refCount++; +} + +// Decrease reference count and return its previous value. +// Delete the document if reference count reaches zero. +int Document::Release() { + int curRefCount = --refCount; + if (curRefCount == 0) + delete this; + return curRefCount; +} + +void Document::SetSavePoint() { + cb.SetSavePoint(); + NotifySavePoint(true); +} + +int Document::GetMark(int line) { + return static_cast(perLineData[ldMarkers])->MarkValue(line); +} + +int Document::AddMark(int line, int markerNum) { + if (line <= LinesTotal()) { + int prev = static_cast(perLineData[ldMarkers])-> + AddMark(line, markerNum, LinesTotal()); + DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line); + NotifyModified(mh); + return prev; + } else { + return 0; + } +} + +void Document::AddMarkSet(int line, int valueSet) { + unsigned int m = valueSet; + for (int i = 0; m; i++, m >>= 1) + if (m & 1) + static_cast(perLineData[ldMarkers])-> + AddMark(line, i, LinesTotal()); + DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line); + NotifyModified(mh); +} + +void Document::DeleteMark(int line, int markerNum) { + static_cast(perLineData[ldMarkers])->DeleteMark(line, markerNum, false); + DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line); + NotifyModified(mh); +} + +void Document::DeleteMarkFromHandle(int markerHandle) { + static_cast(perLineData[ldMarkers])->DeleteMarkFromHandle(markerHandle); + DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0); + mh.line = -1; + NotifyModified(mh); +} + +void Document::DeleteAllMarks(int markerNum) { + for (int line = 0; line < LinesTotal(); line++) { + static_cast(perLineData[ldMarkers])->DeleteMark(line, markerNum, true); + } + DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0); + mh.line = -1; + NotifyModified(mh); +} + +int Document::LineFromHandle(int markerHandle) { + return static_cast(perLineData[ldMarkers])->LineFromHandle(markerHandle); +} + +int Document::LineStart(int line) const { + return cb.LineStart(line); +} + +int Document::LineEnd(int line) const { + if (line == LinesTotal() - 1) { + return LineStart(line + 1); + } else { + int position = LineStart(line + 1) - 1; + // When line terminator is CR+LF, may need to go back one more + if ((position > LineStart(line)) && (cb.CharAt(position - 1) == '\r')) { + position--; + } + return position; + } +} + +int Document::LineFromPosition(int pos) const { + return cb.LineFromPosition(pos); +} + +int Document::LineEndPosition(int position) const { + return LineEnd(LineFromPosition(position)); +} + +bool Document::IsLineEndPosition(int position) const { + return LineEnd(LineFromPosition(position)) == position; +} + +int Document::VCHomePosition(int position) const { + int line = LineFromPosition(position); + int startPosition = LineStart(line); + int endLine = LineEnd(line); + int startText = startPosition; + while (startText < endLine && (cb.CharAt(startText) == ' ' || cb.CharAt(startText) == '\t' ) ) + startText++; + if (position == startText) + return startPosition; + else + return startText; +} + +int Document::SetLevel(int line, int level) { + int prev = static_cast(perLineData[ldLevels])->SetLevel(line, level, LinesTotal()); + if (prev != level) { + DocModification mh(SC_MOD_CHANGEFOLD | SC_MOD_CHANGEMARKER, + LineStart(line), 0, 0, 0, line); + mh.foldLevelNow = level; + mh.foldLevelPrev = prev; + NotifyModified(mh); + } + return prev; +} + +int Document::GetLevel(int line) const { + return static_cast(perLineData[ldLevels])->GetLevel(line); +} + +void Document::ClearLevels() { + static_cast(perLineData[ldLevels])->ClearLevels(); +} + +static bool IsSubordinate(int levelStart, int levelTry) { + if (levelTry & SC_FOLDLEVELWHITEFLAG) + return true; + else + return (levelStart & SC_FOLDLEVELNUMBERMASK) < (levelTry & SC_FOLDLEVELNUMBERMASK); +} + +int Document::GetLastChild(int lineParent, int level) { + if (level == -1) + level = GetLevel(lineParent) & SC_FOLDLEVELNUMBERMASK; + int maxLine = LinesTotal(); + int lineMaxSubord = lineParent; + while (lineMaxSubord < maxLine - 1) { + EnsureStyledTo(LineStart(lineMaxSubord + 2)); + if (!IsSubordinate(level, GetLevel(lineMaxSubord + 1))) + break; + lineMaxSubord++; + } + if (lineMaxSubord > lineParent) { + if (level > (GetLevel(lineMaxSubord + 1) & SC_FOLDLEVELNUMBERMASK)) { + // Have chewed up some whitespace that belongs to a parent so seek back + if (GetLevel(lineMaxSubord) & SC_FOLDLEVELWHITEFLAG) { + lineMaxSubord--; + } + } + } + return lineMaxSubord; +} + +int Document::GetFoldParent(int line) { + int level = GetLevel(line) & SC_FOLDLEVELNUMBERMASK; + int lineLook = line - 1; + while ((lineLook > 0) && ( + (!(GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG)) || + ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) >= level)) + ) { + lineLook--; + } + if ((GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG) && + ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) < level)) { + return lineLook; + } else { + return -1; + } +} + +int Document::ClampPositionIntoDocument(int pos) { + return Platform::Clamp(pos, 0, Length()); +} + +bool Document::IsCrLf(int pos) { + if (pos < 0) + return false; + if (pos >= (Length() - 1)) + return false; + return (cb.CharAt(pos) == '\r') && (cb.CharAt(pos + 1) == '\n'); +} + +static const int maxBytesInDBCSCharacter=5; + +int Document::LenChar(int pos) { + if (pos < 0) { + return 1; + } else if (IsCrLf(pos)) { + return 2; + } else if (SC_CP_UTF8 == dbcsCodePage) { + unsigned char ch = static_cast(cb.CharAt(pos)); + if (ch < 0x80) + return 1; + int len = 2; + if (ch >= (0x80 + 0x40 + 0x20 + 0x10)) + len = 4; + else if (ch >= (0x80 + 0x40 + 0x20)) + len = 3; + int lengthDoc = Length(); + if ((pos + len) > lengthDoc) + return lengthDoc -pos; + else + return len; + } else if (dbcsCodePage) { + char mbstr[maxBytesInDBCSCharacter+1]; + int i; + for (i=0; i= 0x80) && (ch < (0x80 + 0x40)); +} + +static int BytesFromLead(int leadByte) { + if (leadByte > 0xF4) { + // Characters longer than 4 bytes not possible in current UTF-8 + return 0; + } else if (leadByte >= 0xF0) { + return 4; + } else if (leadByte >= 0xE0) { + return 3; + } else if (leadByte >= 0xC2) { + return 2; + } + return 0; +} + +bool Document::InGoodUTF8(int pos, int &start, int &end) { + int lead = pos; + while ((lead>0) && (pos-lead < 4) && IsTrailByte(static_cast(cb.CharAt(lead-1)))) + lead--; + start = 0; + if (lead > 0) { + start = lead-1; + } + int leadByte = static_cast(cb.CharAt(start)); + int bytes = BytesFromLead(leadByte); + if (bytes == 0) { + return false; + } else { + int trailBytes = bytes - 1; + int len = pos - lead + 1; + if (len > trailBytes) + // pos too far from lead + return false; + // Check that there are enough trails for this lead + int trail = pos + 1; + while ((trail-lead(cb.CharAt(trail)))) { + return false; + } + trail++; + } + end = start + bytes; + return true; + } +} + +// Normalise a position so that it is not halfway through a two byte character. +// This can occur in two situations - +// When lines are terminated with \r\n pairs which should be treated as one character. +// When displaying DBCS text such as Japanese. +// If moving, move the position in the indicated direction. +int Document::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) { + //Platform::DebugPrintf("NoCRLF %d %d\n", pos, moveDir); + // If out of range, just return minimum/maximum value. + if (pos <= 0) + return 0; + if (pos >= Length()) + return Length(); + + // PLATFORM_ASSERT(pos > 0 && pos < Length()); + if (checkLineEnd && IsCrLf(pos - 1)) { + if (moveDir > 0) + return pos + 1; + else + return pos - 1; + } + + // Not between CR and LF + + if (dbcsCodePage) { + if (SC_CP_UTF8 == dbcsCodePage) { + unsigned char ch = static_cast(cb.CharAt(pos)); + int startUTF = pos; + int endUTF = pos; + if (IsTrailByte(ch) && InGoodUTF8(pos, startUTF, endUTF)) { + // ch is a trail byte within a UTF-8 character + if (moveDir > 0) + pos = endUTF; + else + pos = startUTF; + } + } else { + // Anchor DBCS calculations at start of line because start of line can + // not be a DBCS trail byte. + int posCheck = LineStart(LineFromPosition(pos)); + while (posCheck < pos) { + char mbstr[maxBytesInDBCSCharacter+1]; + int i; + for(i=0;i pos) { + if (moveDir > 0) { + return posCheck + mbsize; + } else { + return posCheck; + } + } + posCheck += mbsize; + } + } + } + + return pos; +} + +void Document::ModifiedAt(int pos) { + if (endStyled > pos) + endStyled = pos; +} + +void Document::CheckReadOnly() { + if (cb.IsReadOnly() && enteredReadOnlyCount == 0) { + enteredReadOnlyCount++; + NotifyModifyAttempt(); + enteredReadOnlyCount--; + } +} + +// Document only modified by gateways DeleteChars, InsertString, Undo, Redo, and SetStyleAt. +// SetStyleAt does not change the persistent state of a document + +bool Document::DeleteChars(int pos, int len) { + if (len == 0) + return false; + if ((pos + len) > Length()) + return false; + CheckReadOnly(); + if (enteredModification != 0) { + return false; + } else { + enteredModification++; + if (!cb.IsReadOnly()) { + NotifyModified( + DocModification( + SC_MOD_BEFOREDELETE | SC_PERFORMED_USER, + pos, len, + 0, 0)); + int prevLinesTotal = LinesTotal(); + bool startSavePoint = cb.IsSavePoint(); + bool startSequence = false; + const char *text = cb.DeleteChars(pos, len, startSequence); + if (startSavePoint && cb.IsCollectingUndo()) + NotifySavePoint(!startSavePoint); + if ((pos < Length()) || (pos == 0)) + ModifiedAt(pos); + else + ModifiedAt(pos-1); + NotifyModified( + DocModification( + SC_MOD_DELETETEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0), + pos, len, + LinesTotal() - prevLinesTotal, text)); + } + enteredModification--; + } + return !cb.IsReadOnly(); +} + +/** + * Insert a string with a length. + */ +bool Document::InsertString(int position, const char *s, int insertLength) { + if (insertLength <= 0) { + return false; + } + CheckReadOnly(); + if (enteredModification != 0) { + return false; + } else { + enteredModification++; + if (!cb.IsReadOnly()) { + NotifyModified( + DocModification( + SC_MOD_BEFOREINSERT | SC_PERFORMED_USER, + position, insertLength, + 0, s)); + int prevLinesTotal = LinesTotal(); + bool startSavePoint = cb.IsSavePoint(); + bool startSequence = false; + const char *text = cb.InsertString(position, s, insertLength, startSequence); + if (startSavePoint && cb.IsCollectingUndo()) + NotifySavePoint(!startSavePoint); + ModifiedAt(position); + NotifyModified( + DocModification( + SC_MOD_INSERTTEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0), + position, insertLength, + LinesTotal() - prevLinesTotal, text)); + } + enteredModification--; + } + return !cb.IsReadOnly(); +} + +int Document::Undo() { + int newPos = -1; + CheckReadOnly(); + if (enteredModification == 0) { + enteredModification++; + if (!cb.IsReadOnly()) { + bool startSavePoint = cb.IsSavePoint(); + bool multiLine = false; + int steps = cb.StartUndo(); + //Platform::DebugPrintf("Steps=%d\n", steps); + for (int step = 0; step < steps; step++) { + const int prevLinesTotal = LinesTotal(); + const Action &action = cb.GetUndoStep(); + if (action.at == removeAction) { + NotifyModified(DocModification( + SC_MOD_BEFOREINSERT | SC_PERFORMED_UNDO, action)); + } else if (action.at == containerAction) { + DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_UNDO); + dm.token = action.position; + NotifyModified(dm); + } else { + NotifyModified(DocModification( + SC_MOD_BEFOREDELETE | SC_PERFORMED_UNDO, action)); + } + cb.PerformUndoStep(); + int cellPosition = action.position; + if (action.at != containerAction) { + ModifiedAt(cellPosition); + newPos = cellPosition; + } + + int modFlags = SC_PERFORMED_UNDO; + // With undo, an insertion action becomes a deletion notification + if (action.at == removeAction) { + newPos += action.lenData; + modFlags |= SC_MOD_INSERTTEXT; + } else if (action.at == insertAction) { + modFlags |= SC_MOD_DELETETEXT; + } + if (steps > 1) + modFlags |= SC_MULTISTEPUNDOREDO; + const int linesAdded = LinesTotal() - prevLinesTotal; + if (linesAdded != 0) + multiLine = true; + if (step == steps - 1) { + modFlags |= SC_LASTSTEPINUNDOREDO; + if (multiLine) + modFlags |= SC_MULTILINEUNDOREDO; + } + NotifyModified(DocModification(modFlags, cellPosition, action.lenData, + linesAdded, action.data)); + } + + bool endSavePoint = cb.IsSavePoint(); + if (startSavePoint != endSavePoint) + NotifySavePoint(endSavePoint); + } + enteredModification--; + } + return newPos; +} + +int Document::Redo() { + int newPos = -1; + CheckReadOnly(); + if (enteredModification == 0) { + enteredModification++; + if (!cb.IsReadOnly()) { + bool startSavePoint = cb.IsSavePoint(); + bool multiLine = false; + int steps = cb.StartRedo(); + for (int step = 0; step < steps; step++) { + const int prevLinesTotal = LinesTotal(); + const Action &action = cb.GetRedoStep(); + if (action.at == insertAction) { + NotifyModified(DocModification( + SC_MOD_BEFOREINSERT | SC_PERFORMED_REDO, action)); + } else if (action.at == containerAction) { + DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_REDO); + dm.token = action.position; + NotifyModified(dm); + } else { + NotifyModified(DocModification( + SC_MOD_BEFOREDELETE | SC_PERFORMED_REDO, action)); + } + cb.PerformRedoStep(); + if (action.at != containerAction) { + ModifiedAt(action.position); + newPos = action.position; + } + + int modFlags = SC_PERFORMED_REDO; + if (action.at == insertAction) { + newPos += action.lenData; + modFlags |= SC_MOD_INSERTTEXT; + } else if (action.at == removeAction) { + modFlags |= SC_MOD_DELETETEXT; + } + if (steps > 1) + modFlags |= SC_MULTISTEPUNDOREDO; + const int linesAdded = LinesTotal() - prevLinesTotal; + if (linesAdded != 0) + multiLine = true; + if (step == steps - 1) { + modFlags |= SC_LASTSTEPINUNDOREDO; + if (multiLine) + modFlags |= SC_MULTILINEUNDOREDO; + } + NotifyModified( + DocModification(modFlags, action.position, action.lenData, + linesAdded, action.data)); + } + + bool endSavePoint = cb.IsSavePoint(); + if (startSavePoint != endSavePoint) + NotifySavePoint(endSavePoint); + } + enteredModification--; + } + return newPos; +} + +/** + * Insert a single character. + */ +bool Document::InsertChar(int pos, char ch) { + char chs[1]; + chs[0] = ch; + return InsertString(pos, chs, 1); +} + +/** + * Insert a null terminated string. + */ +bool Document::InsertCString(int position, const char *s) { + return InsertString(position, s, strlen(s)); +} + +void Document::ChangeChar(int pos, char ch) { + DeleteChars(pos, 1); + InsertChar(pos, ch); +} + +void Document::DelChar(int pos) { + DeleteChars(pos, LenChar(pos)); +} + +void Document::DelCharBack(int pos) { + if (pos <= 0) { + return; + } else if (IsCrLf(pos - 2)) { + DeleteChars(pos - 2, 2); + } else if (dbcsCodePage) { + int startChar = MovePositionOutsideChar(pos - 1, -1, false); + DeleteChars(startChar, pos - startChar); + } else { + DeleteChars(pos - 1, 1); + } +} + +static bool isindentchar(char ch) { + return (ch == ' ') || (ch == '\t'); +} + +static int NextTab(int pos, int tabSize) { + return ((pos / tabSize) + 1) * tabSize; +} + +static void CreateIndentation(char *linebuf, int length, int indent, int tabSize, bool insertSpaces) { + length--; // ensure space for \0 + if (!insertSpaces) { + while ((indent >= tabSize) && (length > 0)) { + *linebuf++ = '\t'; + indent -= tabSize; + length--; + } + } + while ((indent > 0) && (length > 0)) { + *linebuf++ = ' '; + indent--; + length--; + } + *linebuf = '\0'; +} + +int Document::GetLineIndentation(int line) { + int indent = 0; + if ((line >= 0) && (line < LinesTotal())) { + int lineStart = LineStart(line); + int length = Length(); + for (int i = lineStart;i < length;i++) { + char ch = cb.CharAt(i); + if (ch == ' ') + indent++; + else if (ch == '\t') + indent = NextTab(indent, tabInChars); + else + return indent; + } + } + return indent; +} + +void Document::SetLineIndentation(int line, int indent) { + int indentOfLine = GetLineIndentation(line); + if (indent < 0) + indent = 0; + if (indent != indentOfLine) { + char linebuf[1000]; + CreateIndentation(linebuf, sizeof(linebuf), indent, tabInChars, !useTabs); + int thisLineStart = LineStart(line); + int indentPos = GetLineIndentPosition(line); + UndoGroup ug(this); + DeleteChars(thisLineStart, indentPos - thisLineStart); + InsertCString(thisLineStart, linebuf); + } +} + +int Document::GetLineIndentPosition(int line) const { + if (line < 0) + return 0; + int pos = LineStart(line); + int length = Length(); + while ((pos < length) && isindentchar(cb.CharAt(pos))) { + pos++; + } + return pos; +} + +int Document::GetColumn(int pos) { + int column = 0; + int line = LineFromPosition(pos); + if ((line >= 0) && (line < LinesTotal())) { + for (int i = LineStart(line);i < pos;) { + char ch = cb.CharAt(i); + if (ch == '\t') { + column = NextTab(column, tabInChars); + i++; + } else if (ch == '\r') { + return column; + } else if (ch == '\n') { + return column; + } else if (i >= Length()) { + return column; + } else { + column++; + i = MovePositionOutsideChar(i + 1, 1, false); + } + } + } + return column; +} + +int Document::FindColumn(int line, int column) { + int position = LineStart(line); + if ((line >= 0) && (line < LinesTotal())) { + int columnCurrent = 0; + while ((columnCurrent < column) && (position < Length())) { + char ch = cb.CharAt(position); + if (ch == '\t') { + columnCurrent = NextTab(columnCurrent, tabInChars); + position++; + } else if (ch == '\r') { + return position; + } else if (ch == '\n') { + return position; + } else { + columnCurrent++; + position = MovePositionOutsideChar(position + 1, 1, false); + } + } + } + return position; +} + +void Document::Indent(bool forwards, int lineBottom, int lineTop) { + // Dedent - suck white space off the front of the line to dedent by equivalent of a tab + for (int line = lineBottom; line >= lineTop; line--) { + int indentOfLine = GetLineIndentation(line); + if (forwards) { + if (LineStart(line) < LineEnd(line)) { + SetLineIndentation(line, indentOfLine + IndentSize()); + } + } else { + SetLineIndentation(line, indentOfLine - IndentSize()); + } + } +} + +// Convert line endings for a piece of text to a particular mode. +// Stop at len or when a NUL is found. +// Caller must delete the returned pointer. +char *Document::TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode) { + char *dest = new char[2 * len + 1]; + const char *sptr = s; + char *dptr = dest; + for (size_t i = 0; (i < len) && (*sptr != '\0'); i++) { + if (*sptr == '\n' || *sptr == '\r') { + if (eolMode == SC_EOL_CR) { + *dptr++ = '\r'; + } else if (eolMode == SC_EOL_LF) { + *dptr++ = '\n'; + } else { // eolMode == SC_EOL_CRLF + *dptr++ = '\r'; + *dptr++ = '\n'; + } + if ((*sptr == '\r') && (i+1 < len) && (*(sptr+1) == '\n')) { + i++; + sptr++; + } + sptr++; + } else { + *dptr++ = *sptr++; + } + } + *dptr++ = '\0'; + *pLenOut = (dptr - dest) - 1; + return dest; +} + +void Document::ConvertLineEnds(int eolModeSet) { + UndoGroup ug(this); + + for (int pos = 0; pos < Length(); pos++) { + if (cb.CharAt(pos) == '\r') { + if (cb.CharAt(pos + 1) == '\n') { + // CRLF + if (eolModeSet == SC_EOL_CR) { + DeleteChars(pos + 1, 1); // Delete the LF + } else if (eolModeSet == SC_EOL_LF) { + DeleteChars(pos, 1); // Delete the CR + } else { + pos++; + } + } else { + // CR + if (eolModeSet == SC_EOL_CRLF) { + InsertString(pos + 1, "\n", 1); // Insert LF + pos++; + } else if (eolModeSet == SC_EOL_LF) { + InsertString(pos, "\n", 1); // Insert LF + DeleteChars(pos + 1, 1); // Delete CR + } + } + } else if (cb.CharAt(pos) == '\n') { + // LF + if (eolModeSet == SC_EOL_CRLF) { + InsertString(pos, "\r", 1); // Insert CR + pos++; + } else if (eolModeSet == SC_EOL_CR) { + InsertString(pos, "\r", 1); // Insert CR + DeleteChars(pos + 1, 1); // Delete LF + } + } + } + +} + +bool Document::IsWhiteLine(int line) const { + int currentChar = LineStart(line); + int endLine = LineEnd(line); + while (currentChar < endLine) { + if (cb.CharAt(currentChar) != ' ' && cb.CharAt(currentChar) != '\t') { + return false; + } + ++currentChar; + } + return true; +} + +int Document::ParaUp(int pos) { + int line = LineFromPosition(pos); + line--; + while (line >= 0 && IsWhiteLine(line)) { // skip empty lines + line--; + } + while (line >= 0 && !IsWhiteLine(line)) { // skip non-empty lines + line--; + } + line++; + return LineStart(line); +} + +int Document::ParaDown(int pos) { + int line = LineFromPosition(pos); + while (line < LinesTotal() && !IsWhiteLine(line)) { // skip non-empty lines + line++; + } + while (line < LinesTotal() && IsWhiteLine(line)) { // skip empty lines + line++; + } + if (line < LinesTotal()) + return LineStart(line); + else // end of a document + return LineEnd(line-1); +} + +CharClassify::cc Document::WordCharClass(unsigned char ch) { + if ((SC_CP_UTF8 == dbcsCodePage) && (ch >= 0x80)) + return CharClassify::ccWord; + return charClass.GetClass(ch); +} + +/** + * Used by commmands that want to select whole words. + * Finds the start of word at pos when delta < 0 or the end of the word when delta >= 0. + */ +int Document::ExtendWordSelect(int pos, int delta, bool onlyWordCharacters) { + CharClassify::cc ccStart = CharClassify::ccWord; + if (delta < 0) { + if (!onlyWordCharacters) + ccStart = WordCharClass(cb.CharAt(pos-1)); + while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == ccStart)) + pos--; + } else { + if (!onlyWordCharacters && pos < Length()) + ccStart = WordCharClass(cb.CharAt(pos)); + while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == ccStart)) + pos++; + } + return MovePositionOutsideChar(pos, delta, true); +} + +/** + * Find the start of the next word in either a forward (delta >= 0) or backwards direction + * (delta < 0). + * This is looking for a transition between character classes although there is also some + * additional movement to transit white space. + * Used by cursor movement by word commands. + */ +int Document::NextWordStart(int pos, int delta) { + if (delta < 0) { + while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == CharClassify::ccSpace)) + pos--; + if (pos > 0) { + CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos-1)); + while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == ccStart)) { + pos--; + } + } + } else { + CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos)); + while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == ccStart)) + pos++; + while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == CharClassify::ccSpace)) + pos++; + } + return pos; +} + +/** + * Find the end of the next word in either a forward (delta >= 0) or backwards direction + * (delta < 0). + * This is looking for a transition between character classes although there is also some + * additional movement to transit white space. + * Used by cursor movement by word commands. + */ +int Document::NextWordEnd(int pos, int delta) { + if (delta < 0) { + if (pos > 0) { + CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos-1)); + if (ccStart != CharClassify::ccSpace) { + while (pos > 0 && WordCharClass(cb.CharAt(pos - 1)) == ccStart) { + pos--; + } + } + while (pos > 0 && WordCharClass(cb.CharAt(pos - 1)) == CharClassify::ccSpace) { + pos--; + } + } + } else { + while (pos < Length() && WordCharClass(cb.CharAt(pos)) == CharClassify::ccSpace) { + pos++; + } + if (pos < Length()) { + CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos)); + while (pos < Length() && WordCharClass(cb.CharAt(pos)) == ccStart) { + pos++; + } + } + } + return pos; +} + +/** + * Check that the character at the given position is a word or punctuation character and that + * the previous character is of a different character class. + */ +bool Document::IsWordStartAt(int pos) { + if (pos > 0) { + CharClassify::cc ccPos = WordCharClass(CharAt(pos)); + return (ccPos == CharClassify::ccWord || ccPos == CharClassify::ccPunctuation) && + (ccPos != WordCharClass(CharAt(pos - 1))); + } + return true; +} + +/** + * Check that the character at the given position is a word or punctuation character and that + * the next character is of a different character class. + */ +bool Document::IsWordEndAt(int pos) { + if (pos < Length()) { + CharClassify::cc ccPrev = WordCharClass(CharAt(pos-1)); + return (ccPrev == CharClassify::ccWord || ccPrev == CharClassify::ccPunctuation) && + (ccPrev != WordCharClass(CharAt(pos))); + } + return true; +} + +/** + * Check that the given range is has transitions between character classes at both + * ends and where the characters on the inside are word or punctuation characters. + */ +bool Document::IsWordAt(int start, int end) { + return IsWordStartAt(start) && IsWordEndAt(end); +} + +static inline char MakeLowerCase(char ch) { + if (ch < 'A' || ch > 'Z') + return ch; + else + return static_cast(ch - 'A' + 'a'); +} + +static bool GoodTrailByte(int v) { + return (v >= 0x80) && (v < 0xc0); +} + +size_t Document::ExtractChar(int pos, char *bytes) { + unsigned char ch = static_cast(cb.CharAt(pos)); + size_t widthChar = UTF8CharLength(ch); + bytes[0] = ch; + for (size_t i=1; i(bytes[i]))) { // Bad byte + widthChar = 1; + } + } + return widthChar; +} + +CaseFolderTable::CaseFolderTable() { + for (size_t iChar=0; iChar(iChar); + } +} + +CaseFolderTable::~CaseFolderTable() { +} + +size_t CaseFolderTable::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) { + if (lenMixed > sizeFolded) { + return 0; + } else { + for (size_t i=0; i(mixed[i])]; + } + return lenMixed; + } +} + +void CaseFolderTable::SetTranslation(char ch, char chTranslation) { + mapping[static_cast(ch)] = chTranslation; +} + +void CaseFolderTable::StandardASCII() { + for (size_t iChar=0; iChar= 'A' && iChar <= 'Z') { + mapping[iChar] = static_cast(iChar - 'A' + 'a'); + } else { + mapping[iChar] = static_cast(iChar); + } + } +} + +bool Document::MatchesWordOptions(bool word, bool wordStart, int pos, int length) { + return (!word && !wordStart) || + (word && IsWordAt(pos, pos + length)) || + (wordStart && IsWordStartAt(pos)); +} + +/** + * Find text in document, supporting both forward and backward + * searches (just pass minPos > maxPos to do a backward search) + * Has not been tested with backwards DBCS searches yet. + */ +long Document::FindText(int minPos, int maxPos, const char *search, + bool caseSensitive, bool word, bool wordStart, bool regExp, int flags, + int *length, CaseFolder *pcf) { + if (regExp) { + if (!regex) + regex = CreateRegexSearch(&charClass); + return regex->FindText(this, minPos, maxPos, search, caseSensitive, word, wordStart, flags, length); + } else { + + const bool forward = minPos <= maxPos; + const int increment = forward ? 1 : -1; + + // Range endpoints should not be inside DBCS characters, but just in case, move them. + const int startPos = MovePositionOutsideChar(minPos, increment, false); + const int endPos = MovePositionOutsideChar(maxPos, increment, false); + + // Compute actual search ranges needed + const int lengthFind = (*length == -1) ? static_cast(strlen(search)) : *length; + const int endSearch = (startPos <= endPos) ? endPos - lengthFind + 1 : endPos; + + //Platform::DebugPrintf("Find %d %d %s %d\n", startPos, endPos, ft->lpstrText, lengthFind); + const int limitPos = Platform::Maximum(startPos, endPos); + int pos = forward ? startPos : (startPos - 1); + if (caseSensitive) { + while (forward ? (pos < endSearch) : (pos >= endSearch)) { + bool found = (pos + lengthFind) <= limitPos; + for (int indexSearch = 0; (indexSearch < lengthFind) && found; indexSearch++) { + found = CharAt(pos + indexSearch) == search[indexSearch]; + } + if (found && MatchesWordOptions(word, wordStart, pos, lengthFind)) { + return pos; + } + pos += increment; + if (dbcsCodePage && (pos >= 0)) { + // Have to use >= 0 as otherwise next statement would change + // -1 to 0 and make loop infinite. + // Ensure trying to match from start of character + pos = MovePositionOutsideChar(pos, increment, false); + } + } + } else if (SC_CP_UTF8 == dbcsCodePage) { + const size_t maxBytesCharacter = 4; + const size_t maxFoldingExpansion = 4; + std::vector searchThing(lengthFind * maxBytesCharacter * maxFoldingExpansion + 1); + const int lenSearch = pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind); + while (forward ? (pos < endSearch) : (pos >= endSearch)) { + int widthFirstCharacter = 0; + int indexDocument = 0; + int indexSearch = 0; + bool characterMatches = true; + while (characterMatches && + ((pos + indexDocument) < limitPos) && + (indexSearch < lenSearch)) { + char bytes[maxBytesCharacter + 1]; + bytes[maxBytesCharacter] = 0; + const int widthChar = ExtractChar(pos + indexDocument, bytes); + if (!widthFirstCharacter) + widthFirstCharacter = widthChar; + char folded[maxBytesCharacter * maxFoldingExpansion + 1]; + const int lenFlat = pcf->Fold(folded, sizeof(folded), bytes, widthChar); + folded[lenFlat] = 0; + // Does folded match the buffer + characterMatches = 0 == memcmp(folded, &searchThing[0] + indexSearch, lenFlat); + indexDocument += widthChar; + indexSearch += lenFlat; + } + if (characterMatches && (indexSearch == static_cast(lenSearch))) { + if (MatchesWordOptions(word, wordStart, pos, indexDocument)) { + *length = indexDocument; + return pos; + } + } + if (forward) { + pos += widthFirstCharacter; + } else { + pos--; + if (pos > 0) { + // Ensure trying to match from start of character + pos = MovePositionOutsideChar(pos, increment, false); + } + } + } + } else { + CaseFolderTable caseFolder; + std::vector searchThing(lengthFind + 1); + pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind); + while (forward ? (pos < endSearch) : (pos >= endSearch)) { + bool found = (pos + lengthFind) <= limitPos; + for (int indexSearch = 0; (indexSearch < lengthFind) && found; indexSearch++) { + char ch = CharAt(pos + indexSearch); + char folded[2]; + pcf->Fold(folded, sizeof(folded), &ch, 1); + found = folded[0] == searchThing[indexSearch]; + } + if (found && MatchesWordOptions(word, wordStart, pos, lengthFind)) { + return pos; + } + pos += increment; + if (dbcsCodePage && (pos >= 0)) { + // Ensure trying to match from start of character + pos = MovePositionOutsideChar(pos, increment, false); + } + } + } + } + //Platform::DebugPrintf("Not found\n"); + return -1; +} + +const char *Document::SubstituteByPosition(const char *text, int *length) { + return regex->SubstituteByPosition(this, text, length); +} + +int Document::LinesTotal() const { + return cb.Lines(); +} + +void Document::ChangeCase(Range r, bool makeUpperCase) { + for (int pos = r.start; pos < r.end;) { + int len = LenChar(pos); + if (len == 1) { + char ch = CharAt(pos); + if (makeUpperCase) { + if (IsLowerCase(ch)) { + ChangeChar(pos, static_cast(MakeUpperCase(ch))); + } + } else { + if (IsUpperCase(ch)) { + ChangeChar(pos, static_cast(MakeLowerCase(ch))); + } + } + } + pos += len; + } +} + +void Document::SetDefaultCharClasses(bool includeWordClass) { + charClass.SetDefaultCharClasses(includeWordClass); +} + +void Document::SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass) { + charClass.SetCharClasses(chars, newCharClass); +} + +void Document::SetStylingBits(int bits) { + stylingBits = bits; + stylingBitsMask = (1 << stylingBits) - 1; +} + +void Document::StartStyling(int position, char mask) { + stylingMask = mask; + endStyled = position; +} + +bool Document::SetStyleFor(int length, char style) { + if (enteredStyling != 0) { + return false; + } else { + enteredStyling++; + style &= stylingMask; + int prevEndStyled = endStyled; + if (cb.SetStyleFor(endStyled, length, style, stylingMask)) { + DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER, + prevEndStyled, length); + NotifyModified(mh); + } + endStyled += length; + enteredStyling--; + return true; + } +} + +bool Document::SetStyles(int length, const char *styles) { + if (enteredStyling != 0) { + return false; + } else { + enteredStyling++; + bool didChange = false; + int startMod = 0; + int endMod = 0; + for (int iPos = 0; iPos < length; iPos++, endStyled++) { + PLATFORM_ASSERT(endStyled < Length()); + if (cb.SetStyleAt(endStyled, styles[iPos], stylingMask)) { + if (!didChange) { + startMod = endStyled; + } + didChange = true; + endMod = endStyled; + } + } + if (didChange) { + DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER, + startMod, endMod - startMod + 1); + NotifyModified(mh); + } + enteredStyling--; + return true; + } +} + +void Document::EnsureStyledTo(int pos) { + if ((enteredStyling == 0) && (pos > GetEndStyled())) { + IncrementStyleClock(); + // Ask the watchers to style, and stop as soon as one responds. + for (int i = 0; pos > GetEndStyled() && i < lenWatchers; i++) { + watchers[i].watcher->NotifyStyleNeeded(this, watchers[i].userData, pos); + } + } +} + +int Document::SetLineState(int line, int state) { + int statePrevious = static_cast(perLineData[ldState])->SetLineState(line, state); + if (state != statePrevious) { + DocModification mh(SC_MOD_CHANGELINESTATE, 0, 0, 0, 0, line); + NotifyModified(mh); + } + return statePrevious; +} + +int Document::GetLineState(int line) const { + return static_cast(perLineData[ldState])->GetLineState(line); +} + +int Document::GetMaxLineState() { + return static_cast(perLineData[ldState])->GetMaxLineState(); +} + +StyledText Document::MarginStyledText(int line) { + LineAnnotation *pla = static_cast(perLineData[ldMargin]); + return StyledText(pla->Length(line), pla->Text(line), + pla->MultipleStyles(line), pla->Style(line), pla->Styles(line)); +} + +void Document::MarginSetText(int line, const char *text) { + static_cast(perLineData[ldMargin])->SetText(line, text); + DocModification mh(SC_MOD_CHANGEMARGIN, LineStart(line), 0, 0, 0, line); + NotifyModified(mh); +} + +void Document::MarginSetStyle(int line, int style) { + static_cast(perLineData[ldMargin])->SetStyle(line, style); +} + +void Document::MarginSetStyles(int line, const unsigned char *styles) { + static_cast(perLineData[ldMargin])->SetStyles(line, styles); +} + +int Document::MarginLength(int line) const { + return static_cast(perLineData[ldMargin])->Length(line); +} + +void Document::MarginClearAll() { + int maxEditorLine = LinesTotal(); + for (int l=0;l(perLineData[ldMargin])->ClearAll(); +} + +bool Document::AnnotationAny() const { + return static_cast(perLineData[ldAnnotation])->AnySet(); +} + +StyledText Document::AnnotationStyledText(int line) { + LineAnnotation *pla = static_cast(perLineData[ldAnnotation]); + return StyledText(pla->Length(line), pla->Text(line), + pla->MultipleStyles(line), pla->Style(line), pla->Styles(line)); +} + +void Document::AnnotationSetText(int line, const char *text) { + const int linesBefore = AnnotationLines(line); + static_cast(perLineData[ldAnnotation])->SetText(line, text); + const int linesAfter = AnnotationLines(line); + DocModification mh(SC_MOD_CHANGEANNOTATION, LineStart(line), 0, 0, 0, line); + mh.annotationLinesAdded = linesAfter - linesBefore; + NotifyModified(mh); +} + +void Document::AnnotationSetStyle(int line, int style) { + static_cast(perLineData[ldAnnotation])->SetStyle(line, style); +} + +void Document::AnnotationSetStyles(int line, const unsigned char *styles) { + static_cast(perLineData[ldAnnotation])->SetStyles(line, styles); +} + +int Document::AnnotationLength(int line) const { + return static_cast(perLineData[ldAnnotation])->Length(line); +} + +int Document::AnnotationLines(int line) const { + return static_cast(perLineData[ldAnnotation])->Lines(line); +} + +void Document::AnnotationClearAll() { + int maxEditorLine = LinesTotal(); + for (int l=0;l(perLineData[ldAnnotation])->ClearAll(); +} + +void Document::IncrementStyleClock() { + styleClock = (styleClock + 1) % 0x100000; +} + +void Document::DecorationFillRange(int position, int value, int fillLength) { + if (decorations.FillRange(position, value, fillLength)) { + DocModification mh(SC_MOD_CHANGEINDICATOR | SC_PERFORMED_USER, + position, fillLength); + NotifyModified(mh); + } +} + +bool Document::AddWatcher(DocWatcher *watcher, void *userData) { + for (int i = 0; i < lenWatchers; i++) { + if ((watchers[i].watcher == watcher) && + (watchers[i].userData == userData)) + return false; + } + WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers + 1]; + for (int j = 0; j < lenWatchers; j++) + pwNew[j] = watchers[j]; + pwNew[lenWatchers].watcher = watcher; + pwNew[lenWatchers].userData = userData; + delete []watchers; + watchers = pwNew; + lenWatchers++; + return true; +} + +bool Document::RemoveWatcher(DocWatcher *watcher, void *userData) { + for (int i = 0; i < lenWatchers; i++) { + if ((watchers[i].watcher == watcher) && + (watchers[i].userData == userData)) { + if (lenWatchers == 1) { + delete []watchers; + watchers = 0; + lenWatchers = 0; + } else { + WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers]; + for (int j = 0; j < lenWatchers - 1; j++) { + pwNew[j] = (j < i) ? watchers[j] : watchers[j + 1]; + } + delete []watchers; + watchers = pwNew; + lenWatchers--; + } + return true; + } + } + return false; +} + +void Document::NotifyModifyAttempt() { + for (int i = 0; i < lenWatchers; i++) { + watchers[i].watcher->NotifyModifyAttempt(this, watchers[i].userData); + } +} + +void Document::NotifySavePoint(bool atSavePoint) { + for (int i = 0; i < lenWatchers; i++) { + watchers[i].watcher->NotifySavePoint(this, watchers[i].userData, atSavePoint); + } +} + +void Document::NotifyModified(DocModification mh) { + if (mh.modificationType & SC_MOD_INSERTTEXT) { + decorations.InsertSpace(mh.position, mh.length); + } else if (mh.modificationType & SC_MOD_DELETETEXT) { + decorations.DeleteRange(mh.position, mh.length); + } + for (int i = 0; i < lenWatchers; i++) { + watchers[i].watcher->NotifyModified(this, mh, watchers[i].userData); + } +} + +bool Document::IsWordPartSeparator(char ch) { + return (WordCharClass(ch) == CharClassify::ccWord) && IsPunctuation(ch); +} + +int Document::WordPartLeft(int pos) { + if (pos > 0) { + --pos; + char startChar = cb.CharAt(pos); + if (IsWordPartSeparator(startChar)) { + while (pos > 0 && IsWordPartSeparator(cb.CharAt(pos))) { + --pos; + } + } + if (pos > 0) { + startChar = cb.CharAt(pos); + --pos; + if (IsLowerCase(startChar)) { + while (pos > 0 && IsLowerCase(cb.CharAt(pos))) + --pos; + if (!IsUpperCase(cb.CharAt(pos)) && !IsLowerCase(cb.CharAt(pos))) + ++pos; + } else if (IsUpperCase(startChar)) { + while (pos > 0 && IsUpperCase(cb.CharAt(pos))) + --pos; + if (!IsUpperCase(cb.CharAt(pos))) + ++pos; + } else if (IsADigit(startChar)) { + while (pos > 0 && IsADigit(cb.CharAt(pos))) + --pos; + if (!IsADigit(cb.CharAt(pos))) + ++pos; + } else if (IsPunctuation(startChar)) { + while (pos > 0 && IsPunctuation(cb.CharAt(pos))) + --pos; + if (!IsPunctuation(cb.CharAt(pos))) + ++pos; + } else if (isspacechar(startChar)) { + while (pos > 0 && isspacechar(cb.CharAt(pos))) + --pos; + if (!isspacechar(cb.CharAt(pos))) + ++pos; + } else if (!isascii(startChar)) { + while (pos > 0 && !isascii(cb.CharAt(pos))) + --pos; + if (isascii(cb.CharAt(pos))) + ++pos; + } else { + ++pos; + } + } + } + return pos; +} + +int Document::WordPartRight(int pos) { + char startChar = cb.CharAt(pos); + int length = Length(); + if (IsWordPartSeparator(startChar)) { + while (pos < length && IsWordPartSeparator(cb.CharAt(pos))) + ++pos; + startChar = cb.CharAt(pos); + } + if (!isascii(startChar)) { + while (pos < length && !isascii(cb.CharAt(pos))) + ++pos; + } else if (IsLowerCase(startChar)) { + while (pos < length && IsLowerCase(cb.CharAt(pos))) + ++pos; + } else if (IsUpperCase(startChar)) { + if (IsLowerCase(cb.CharAt(pos + 1))) { + ++pos; + while (pos < length && IsLowerCase(cb.CharAt(pos))) + ++pos; + } else { + while (pos < length && IsUpperCase(cb.CharAt(pos))) + ++pos; + } + if (IsLowerCase(cb.CharAt(pos)) && IsUpperCase(cb.CharAt(pos - 1))) + --pos; + } else if (IsADigit(startChar)) { + while (pos < length && IsADigit(cb.CharAt(pos))) + ++pos; + } else if (IsPunctuation(startChar)) { + while (pos < length && IsPunctuation(cb.CharAt(pos))) + ++pos; + } else if (isspacechar(startChar)) { + while (pos < length && isspacechar(cb.CharAt(pos))) + ++pos; + } else { + ++pos; + } + return pos; +} + +bool IsLineEndChar(char c) { + return (c == '\n' || c == '\r'); +} + +int Document::ExtendStyleRange(int pos, int delta, bool singleLine) { + int sStart = cb.StyleAt(pos); + if (delta < 0) { + while (pos > 0 && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))) ) + pos--; + pos++; + } else { + while (pos < (Length()) && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))) ) + pos++; + } + return pos; +} + +static char BraceOpposite(char ch) { + switch (ch) { + case '(': + return ')'; + case ')': + return '('; + case '[': + return ']'; + case ']': + return '['; + case '{': + return '}'; + case '}': + return '{'; + case '<': + return '>'; + case '>': + return '<'; + default: + return '\0'; + } +} + +// TODO: should be able to extend styled region to find matching brace +int Document::BraceMatch(int position, int /*maxReStyle*/) { + char chBrace = CharAt(position); + char chSeek = BraceOpposite(chBrace); + if (chSeek == '\0') + return - 1; + char styBrace = static_cast(StyleAt(position) & stylingBitsMask); + int direction = -1; + if (chBrace == '(' || chBrace == '[' || chBrace == '{' || chBrace == '<') + direction = 1; + int depth = 1; + position = position + direction; + while ((position >= 0) && (position < Length())) { + position = MovePositionOutsideChar(position, direction, true); + char chAtPos = CharAt(position); + char styAtPos = static_cast(StyleAt(position) & stylingBitsMask); + if ((position > GetEndStyled()) || (styAtPos == styBrace)) { + if (chAtPos == chBrace) + depth++; + if (chAtPos == chSeek) + depth--; + if (depth == 0) + return position; + } + position = position + direction; + } + return - 1; +} + +/** + * Implementation of RegexSearchBase for the default built-in regular expression engine + */ +class BuiltinRegex : public RegexSearchBase { +public: + BuiltinRegex(CharClassify *charClassTable) : search(charClassTable), substituted(NULL) {} + + virtual ~BuiltinRegex() { + delete substituted; + } + + virtual long FindText(Document *doc, int minPos, int maxPos, const char *s, + bool caseSensitive, bool word, bool wordStart, int flags, + int *length); + + virtual const char *SubstituteByPosition(Document* doc, const char *text, int *length); + +private: + RESearch search; + char *substituted; +}; + +// Define a way for the Regular Expression code to access the document +class DocumentIndexer : public CharacterIndexer { + Document *pdoc; + int end; +public: + DocumentIndexer(Document *pdoc_, int end_) : + pdoc(pdoc_), end(end_) { + } + + virtual ~DocumentIndexer() { + } + + virtual char CharAt(int index) { + if (index < 0 || index >= end) + return 0; + else + return pdoc->CharAt(index); + } +}; + +long BuiltinRegex::FindText(Document *doc, int minPos, int maxPos, const char *s, + bool caseSensitive, bool, bool, int flags, + int *length) { + bool posix = (flags & SCFIND_POSIX) != 0; + int increment = (minPos <= maxPos) ? 1 : -1; + + int startPos = minPos; + int endPos = maxPos; + + // Range endpoints should not be inside DBCS characters, but just in case, move them. + startPos = doc->MovePositionOutsideChar(startPos, 1, false); + endPos = doc->MovePositionOutsideChar(endPos, 1, false); + + const char *errmsg = search.Compile(s, *length, caseSensitive, posix); + if (errmsg) { + return -1; + } + // Find a variable in a property file: \$(\([A-Za-z0-9_.]+\)) + // Replace first '.' with '-' in each property file variable reference: + // Search: \$(\([A-Za-z0-9_-]+\)\.\([A-Za-z0-9_.]+\)) + // Replace: $(\1-\2) + int lineRangeStart = doc->LineFromPosition(startPos); + int lineRangeEnd = doc->LineFromPosition(endPos); + if ((increment == 1) && + (startPos >= doc->LineEnd(lineRangeStart)) && + (lineRangeStart < lineRangeEnd)) { + // the start position is at end of line or between line end characters. + lineRangeStart++; + startPos = doc->LineStart(lineRangeStart); + } + int pos = -1; + int lenRet = 0; + char searchEnd = s[*length - 1]; + int lineRangeBreak = lineRangeEnd + increment; + for (int line = lineRangeStart; line != lineRangeBreak; line += increment) { + int startOfLine = doc->LineStart(line); + int endOfLine = doc->LineEnd(line); + if (increment == 1) { + if (line == lineRangeStart) { + if ((startPos != startOfLine) && (s[0] == '^')) + continue; // Can't match start of line if start position after start of line + startOfLine = startPos; + } + if (line == lineRangeEnd) { + if ((endPos != endOfLine) && (searchEnd == '$')) + continue; // Can't match end of line if end position before end of line + endOfLine = endPos; + } + } else { + if (line == lineRangeEnd) { + if ((endPos != startOfLine) && (s[0] == '^')) + continue; // Can't match start of line if end position after start of line + startOfLine = endPos; + } + if (line == lineRangeStart) { + if ((startPos != endOfLine) && (searchEnd == '$')) + continue; // Can't match end of line if start position before end of line + endOfLine = startPos; + } + } + + DocumentIndexer di(doc, endOfLine); + int success = search.Execute(di, startOfLine, endOfLine); + if (success) { + pos = search.bopat[0]; + lenRet = search.eopat[0] - search.bopat[0]; + if (increment == -1) { + // Check for the last match on this line. + int repetitions = 1000; // Break out of infinite loop + while (success && (search.eopat[0] <= endOfLine) && (repetitions--)) { + success = search.Execute(di, pos+1, endOfLine); + if (success) { + if (search.eopat[0] <= minPos) { + pos = search.bopat[0]; + lenRet = search.eopat[0] - search.bopat[0]; + } else { + success = 0; + } + } + } + } + break; + } + } + *length = lenRet; + return pos; +} + +const char *BuiltinRegex::SubstituteByPosition(Document* doc, const char *text, int *length) { + delete []substituted; + substituted = 0; + DocumentIndexer di(doc, doc->Length()); + if (!search.GrabMatches(di)) + return 0; + unsigned int lenResult = 0; + for (int i = 0; i < *length; i++) { + if (text[i] == '\\') { + if (text[i + 1] >= '1' && text[i + 1] <= '9') { + unsigned int patNum = text[i + 1] - '0'; + lenResult += search.eopat[patNum] - search.bopat[patNum]; + i++; + } else { + switch (text[i + 1]) { + case 'a': + case 'b': + case 'f': + case 'n': + case 'r': + case 't': + case 'v': + case '\\': + i++; + } + lenResult++; + } + } else { + lenResult++; + } + } + substituted = new char[lenResult + 1]; + char *o = substituted; + for (int j = 0; j < *length; j++) { + if (text[j] == '\\') { + if (text[j + 1] >= '1' && text[j + 1] <= '9') { + unsigned int patNum = text[j + 1] - '0'; + unsigned int len = search.eopat[patNum] - search.bopat[patNum]; + if (search.pat[patNum]) // Will be null if try for a match that did not occur + memcpy(o, search.pat[patNum], len); + o += len; + j++; + } else { + j++; + switch (text[j]) { + case 'a': + *o++ = '\a'; + break; + case 'b': + *o++ = '\b'; + break; + case 'f': + *o++ = '\f'; + break; + case 'n': + *o++ = '\n'; + break; + case 'r': + *o++ = '\r'; + break; + case 't': + *o++ = '\t'; + break; + case 'v': + *o++ = '\v'; + break; + case '\\': + *o++ = '\\'; + break; + default: + *o++ = '\\'; + j--; + } + } + } else { + *o++ = text[j]; + } + } + *o = '\0'; + *length = lenResult; + return substituted; +} + +#ifndef SCI_OWNREGEX + +#ifdef SCI_NAMESPACE + +RegexSearchBase *Scintilla::CreateRegexSearch(CharClassify *charClassTable) { + return new BuiltinRegex(charClassTable); +} + +#else + +RegexSearchBase *CreateRegexSearch(CharClassify *charClassTable) { + return new BuiltinRegex(charClassTable); +} + +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/Document.h b/sdk/wxscintilla/src/scintilla/src/Document.h new file mode 100644 index 0000000..d4964f0 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Document.h @@ -0,0 +1,426 @@ +// Scintilla source code edit control +/** @file Document.h + ** Text document that handles notifications, DBCS, styling, words and end of line. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef DOCUMENT_H +#define DOCUMENT_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + * A Position is a position within a document between two characters or at the beginning or end. + * Sometimes used as a character index where it identifies the character after the position. + */ +typedef int Position; +const Position invalidPosition = -1; + +/** + * The range class represents a range of text in a document. + * The two values are not sorted as one end may be more significant than the other + * as is the case for the selection where the end position is the position of the caret. + * If either position is invalidPosition then the range is invalid and most operations will fail. + */ +class Range { +public: + Position start; + Position end; + + Range(Position pos=0) : + start(pos), end(pos) { + } + Range(Position start_, Position end_) : + start(start_), end(end_) { + } + + bool Valid() const { + return (start != invalidPosition) && (end != invalidPosition); + } + + // Is the position within the range? + bool Contains(Position pos) const { + if (start < end) { + return (pos >= start && pos <= end); + } else { + return (pos <= start && pos >= end); + } + } + + // Is the character after pos within the range? + bool ContainsCharacter(Position pos) const { + if (start < end) { + return (pos >= start && pos < end); + } else { + return (pos < start && pos >= end); + } + } + + bool Contains(Range other) const { + return Contains(other.start) && Contains(other.end); + } + + bool Overlaps(Range other) const { + return + Contains(other.start) || + Contains(other.end) || + other.Contains(start) || + other.Contains(end); + } +}; + +class DocWatcher; +class DocModification; +class Document; + +/** + * Interface class for regular expression searching + */ +class RegexSearchBase { +public: + virtual ~RegexSearchBase(){} + + virtual long FindText(Document* doc, int minPos, int maxPos, const char *s, + bool caseSensitive, bool word, bool wordStart, int flags, int *length) = 0; + + ///@return String with the substitutions, must remain valid until the next call or destruction + virtual const char *SubstituteByPosition(Document* doc, const char *text, int *length) = 0; +}; + +/// Factory function for RegexSearchBase +extern RegexSearchBase* CreateRegexSearch(CharClassify *charClassTable); + +struct StyledText { + size_t length; + const char *text; + bool multipleStyles; + size_t style; + const unsigned char *styles; + StyledText( size_t length_, const char *text_, bool multipleStyles_, int style_, const unsigned char *styles_) : + length(length_), text(text_), multipleStyles(multipleStyles_), style(style_), styles(styles_) { + } + // Return number of bytes from start to before '\n' or end of text. + // Return 1 when start is outside text + size_t LineLength(size_t start) const { + size_t cur = start; + while ((cur < length) && (text[cur] != '\n')) + cur++; + return cur-start; + } + size_t StyleAt(size_t i) const { + return multipleStyles ? styles[i] : style; + } +}; + +class CaseFolder { +public: + virtual ~CaseFolder() { + } + virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) = 0; +}; + +class CaseFolderTable : public CaseFolder { +protected: + char mapping[256]; +public: + CaseFolderTable(); + virtual ~CaseFolderTable(); + virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed); + void SetTranslation(char ch, char chTranslation); + void StandardASCII(); +}; + +/** + */ +class Document : PerLine { + +public: + /** Used to pair watcher pointer with user data. */ + class WatcherWithUserData { + public: + DocWatcher *watcher; + void *userData; + WatcherWithUserData() { + watcher = 0; + userData = 0; + } + }; + + enum charClassification { ccSpace, ccNewLine, ccWord, ccPunctuation }; +private: + int refCount; + CellBuffer cb; + CharClassify charClass; + char stylingMask; + int endStyled; + int styleClock; + int enteredModification; + int enteredStyling; + int enteredReadOnlyCount; + + WatcherWithUserData *watchers; + int lenWatchers; + + // ldSize is not real data - it is for dimensions and loops + enum lineData { ldMarkers, ldLevels, ldState, ldMargin, ldAnnotation, ldSize }; + PerLine *perLineData[ldSize]; + + bool matchesValid; + RegexSearchBase* regex; + +public: + int stylingBits; + int stylingBitsMask; + + int eolMode; + /// Can also be SC_CP_UTF8 to enable UTF-8 mode + int dbcsCodePage; + int tabInChars; + int indentInChars; + int actualIndentInChars; + bool useTabs; + bool tabIndents; + bool backspaceUnindents; + + DecorationList decorations; + + Document(); + virtual ~Document(); + + int AddRef(); + int Release(); + + virtual void Init(); + virtual void InsertLine(int line); + virtual void RemoveLine(int line); + + int LineFromPosition(int pos) const; + int ClampPositionIntoDocument(int pos); + bool IsCrLf(int pos); + int LenChar(int pos); + bool InGoodUTF8(int pos, int &start, int &end); + int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true); + + // Gateways to modifying document + void ModifiedAt(int pos); + void CheckReadOnly(); + bool DeleteChars(int pos, int len); + bool InsertString(int position, const char *s, int insertLength); + int Undo(); + int Redo(); + bool CanUndo() { return cb.CanUndo(); } + bool CanRedo() { return cb.CanRedo(); } + void DeleteUndoHistory() { cb.DeleteUndoHistory(); } + bool SetUndoCollection(bool collectUndo) { + return cb.SetUndoCollection(collectUndo); + } + bool IsCollectingUndo() { return cb.IsCollectingUndo(); } + void BeginUndoAction() { cb.BeginUndoAction(); } + void EndUndoAction() { cb.EndUndoAction(); } + void AddUndoAction(int token, bool mayCoalesce) { cb.AddUndoAction(token, mayCoalesce); } + void SetSavePoint(); + bool IsSavePoint() { return cb.IsSavePoint(); } + const char *BufferPointer() { return cb.BufferPointer(); } + + int GetLineIndentation(int line); + void SetLineIndentation(int line, int indent); + int GetLineIndentPosition(int line) const; + int GetColumn(int position); + int FindColumn(int line, int column); + void Indent(bool forwards, int lineBottom, int lineTop); + static char *TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode); + void ConvertLineEnds(int eolModeSet); + void SetReadOnly(bool set) { cb.SetReadOnly(set); } + bool IsReadOnly() { return cb.IsReadOnly(); } + + bool InsertChar(int pos, char ch); + bool InsertCString(int position, const char *s); + void ChangeChar(int pos, char ch); + void DelChar(int pos); + void DelCharBack(int pos); + + char CharAt(int position) { return cb.CharAt(position); } + void GetCharRange(char *buffer, int position, int lengthRetrieve) const { + cb.GetCharRange(buffer, position, lengthRetrieve); + } + char StyleAt(int position) const { return cb.StyleAt(position); } + int GetMark(int line); + int AddMark(int line, int markerNum); + void AddMarkSet(int line, int valueSet); + void DeleteMark(int line, int markerNum); + void DeleteMarkFromHandle(int markerHandle); + void DeleteAllMarks(int markerNum); + int LineFromHandle(int markerHandle); + int LineStart(int line) const; + int LineEnd(int line) const; + int LineEndPosition(int position) const; + bool IsLineEndPosition(int position) const; + int VCHomePosition(int position) const; + + int SetLevel(int line, int level); + int GetLevel(int line) const; + void ClearLevels(); + int GetLastChild(int lineParent, int level=-1); + int GetFoldParent(int line); + + void Indent(bool forwards); + int ExtendWordSelect(int pos, int delta, bool onlyWordCharacters=false); + int NextWordStart(int pos, int delta); + int NextWordEnd(int pos, int delta); + int Length() const { return cb.Length(); } + void Allocate(int newSize) { cb.Allocate(newSize); } + size_t ExtractChar(int pos, char *bytes); + bool MatchesWordOptions(bool word, bool wordStart, int pos, int length); + long FindText(int minPos, int maxPos, const char *search, bool caseSensitive, bool word, + bool wordStart, bool regExp, int flags, int *length, CaseFolder *pcf); + const char *SubstituteByPosition(const char *text, int *length); + int LinesTotal() const; + + void ChangeCase(Range r, bool makeUpperCase); + + void SetDefaultCharClasses(bool includeWordClass); + void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass); + void SetStylingBits(int bits); + void StartStyling(int position, char mask); + bool SetStyleFor(int length, char style); + bool SetStyles(int length, const char *styles); + int GetEndStyled() { return endStyled; } + void EnsureStyledTo(int pos); + int GetStyleClock() { return styleClock; } + void IncrementStyleClock(); + void DecorationFillRange(int position, int value, int fillLength); + + int SetLineState(int line, int state); + int GetLineState(int line) const; + int GetMaxLineState(); + + StyledText MarginStyledText(int line); + void MarginSetStyle(int line, int style); + void MarginSetStyles(int line, const unsigned char *styles); + void MarginSetText(int line, const char *text); + int MarginLength(int line) const; + void MarginClearAll(); + + bool AnnotationAny() const; + StyledText AnnotationStyledText(int line); + void AnnotationSetText(int line, const char *text); + void AnnotationSetStyle(int line, int style); + void AnnotationSetStyles(int line, const unsigned char *styles); + int AnnotationLength(int line) const; + int AnnotationLines(int line) const; + void AnnotationClearAll(); + + bool AddWatcher(DocWatcher *watcher, void *userData); + bool RemoveWatcher(DocWatcher *watcher, void *userData); + const WatcherWithUserData *GetWatchers() const { return watchers; } + int GetLenWatchers() const { return lenWatchers; } + + bool IsWordPartSeparator(char ch); + int WordPartLeft(int pos); + int WordPartRight(int pos); + int ExtendStyleRange(int pos, int delta, bool singleLine = false); + bool IsWhiteLine(int line) const; + int ParaUp(int pos); + int ParaDown(int pos); + int IndentSize() { return actualIndentInChars; } + int BraceMatch(int position, int maxReStyle); + +private: + CharClassify::cc WordCharClass(unsigned char ch); + bool IsWordStartAt(int pos); + bool IsWordEndAt(int pos); + bool IsWordAt(int start, int end); + + void NotifyModifyAttempt(); + void NotifySavePoint(bool atSavePoint); + void NotifyModified(DocModification mh); +}; + +class UndoGroup { + Document *pdoc; + bool groupNeeded; +public: + UndoGroup(Document *pdoc_, bool groupNeeded_=true) : + pdoc(pdoc_), groupNeeded(groupNeeded_) { + if (groupNeeded) { + pdoc->BeginUndoAction(); + } + } + ~UndoGroup() { + if (groupNeeded) { + pdoc->EndUndoAction(); + } + } + bool Needed() const { + return groupNeeded; + } +}; + + +/** + * To optimise processing of document modifications by DocWatchers, a hint is passed indicating the + * scope of the change. + * If the DocWatcher is a document view then this can be used to optimise screen updating. + */ +class DocModification { +public: + int modificationType; + int position; + int length; + int linesAdded; /**< Negative if lines deleted. */ + const char *text; /**< Only valid for changes to text, not for changes to style. */ + int line; + int foldLevelNow; + int foldLevelPrev; + int annotationLinesAdded; + int token; + + DocModification(int modificationType_, int position_=0, int length_=0, + int linesAdded_=0, const char *text_=0, int line_=0) : + modificationType(modificationType_), + position(position_), + length(length_), + linesAdded(linesAdded_), + text(text_), + line(line_), + foldLevelNow(0), + foldLevelPrev(0), + annotationLinesAdded(0), + token(0) {} + + DocModification(int modificationType_, const Action &act, int linesAdded_=0) : + modificationType(modificationType_), + position(act.position), + length(act.lenData), + linesAdded(linesAdded_), + text(act.data), + line(0), + foldLevelNow(0), + foldLevelPrev(0), + annotationLinesAdded(0), + token(0) {} +}; + +/** + * A class that wants to receive notifications from a Document must be derived from DocWatcher + * and implement the notification methods. It can then be added to the watcher list with AddWatcher. + */ +class DocWatcher { +public: + virtual ~DocWatcher() {} + + virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0; + virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0; + virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0; + virtual void NotifyDeleted(Document *doc, void *userData) = 0; + virtual void NotifyStyleNeeded(Document *doc, void *userData, int endPos) = 0; +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/DocumentAccessor.cxx b/sdk/wxscintilla/src/scintilla/src/DocumentAccessor.cxx new file mode 100644 index 0000000..a25979d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/DocumentAccessor.cxx @@ -0,0 +1,199 @@ +// Scintilla source code edit control +/** @file DocumentAccessor.cxx + ** Rapid easy access to contents of a Scintilla. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "DocumentAccessor.h" +#include "SplitVector.h" +#include "Partitioning.h" +#include "RunStyles.h" +#include "CellBuffer.h" +#include "Scintilla.h" +#include "CharClassify.h" +#include "Decoration.h" +#include "Document.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +DocumentAccessor::~DocumentAccessor() { +} + +bool DocumentAccessor::InternalIsLeadByte(char ch) { + if (SC_CP_UTF8 == codePage) + // For lexing, all characters >= 0x80 are treated the + // same so none is considered a lead byte. + return false; + else + return Platform::IsDBCSLeadByte(codePage, ch); +} + +void DocumentAccessor::Fill(int position) { + if (lenDoc == -1) + lenDoc = pdoc->Length(); + startPos = position - slopSize; + if (startPos + bufferSize > lenDoc) + startPos = lenDoc - bufferSize; + if (startPos < 0) + startPos = 0; + endPos = startPos + bufferSize; + if (endPos > lenDoc) + endPos = lenDoc; + + pdoc->GetCharRange(buf, startPos, endPos-startPos); + buf[endPos-startPos] = '\0'; +} + +bool DocumentAccessor::Match(int pos, const char *s) { + for (int i=0; *s; i++) { + if (*s != SafeGetCharAt(pos+i)) + return false; + s++; + } + return true; +} + +char DocumentAccessor::StyleAt(int position) { + // Mask off all bits which aren't in the 'mask'. + return static_cast(pdoc->StyleAt(position) & mask); +} + +int DocumentAccessor::GetLine(int position) { + return pdoc->LineFromPosition(position); +} + +int DocumentAccessor::LineStart(int line) { + return pdoc->LineStart(line); +} + +int DocumentAccessor::LevelAt(int line) { + return pdoc->GetLevel(line); +} + +int DocumentAccessor::Length() { + if (lenDoc == -1) + lenDoc = pdoc->Length(); + return lenDoc; +} + +int DocumentAccessor::GetLineState(int line) { + return pdoc->GetLineState(line); +} + +int DocumentAccessor::SetLineState(int line, int state) { + return pdoc->SetLineState(line, state); +} + +void DocumentAccessor::StartAt(unsigned int start, char chMask) { + // Store the mask specified for use with StyleAt. + mask = chMask; + pdoc->StartStyling(start, chMask); + startPosStyling = start; +} + +void DocumentAccessor::StartSegment(unsigned int pos) { + startSeg = pos; +} + +void DocumentAccessor::ColourTo(unsigned int pos, int chAttr) { + // Only perform styling if non empty range + if (pos != startSeg - 1) { + PLATFORM_ASSERT(pos >= startSeg); + if (pos < startSeg) { + return; + } + + if (validLen + (pos - startSeg + 1) >= bufferSize) + Flush(); + if (validLen + (pos - startSeg + 1) >= bufferSize) { + // Too big for buffer so send directly + pdoc->SetStyleFor(pos - startSeg + 1, static_cast(chAttr)); + } else { + if (chAttr != chWhile) + chFlags = 0; + chAttr |= chFlags; + for (unsigned int i = startSeg; i <= pos; i++) { + PLATFORM_ASSERT((startPosStyling + validLen) < Length()); + styleBuf[validLen++] = static_cast(chAttr); + } + } + } + startSeg = pos+1; +} + +void DocumentAccessor::SetLevel(int line, int level) { + pdoc->SetLevel(line, level); +} + +void DocumentAccessor::Flush() { + startPos = extremePosition; + lenDoc = -1; + if (validLen > 0) { + pdoc->SetStyles(validLen, styleBuf); + startPosStyling += validLen; + validLen = 0; + } +} + +int DocumentAccessor::IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) { + int end = Length(); + int spaceFlags = 0; + + // Determines the indentation level of the current line and also checks for consistent + // indentation compared to the previous line. + // Indentation is judged consistent when the indentation whitespace of each line lines + // the same or the indentation of one line is a prefix of the other. + + int pos = LineStart(line); + char ch = (*this)[pos]; + int indent = 0; + bool inPrevPrefix = line > 0; + int posPrev = inPrevPrefix ? LineStart(line-1) : 0; + while ((ch == ' ' || ch == '\t') && (pos < end)) { + if (inPrevPrefix) { + char chPrev = (*this)[posPrev++]; + if (chPrev == ' ' || chPrev == '\t') { + if (chPrev != ch) + spaceFlags |= wsInconsistent; + } else { + inPrevPrefix = false; + } + } + if (ch == ' ') { + spaceFlags |= wsSpace; + indent++; + } else { // Tab + spaceFlags |= wsTab; + if (spaceFlags & wsSpace) + spaceFlags |= wsSpaceTab; + indent = (indent / 8 + 1) * 8; + } + ch = (*this)[++pos]; + } + + *flags = spaceFlags; + indent += SC_FOLDLEVELBASE; + // if completely empty line or the start of a comment... + if ((ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') || + (pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos)) ) + return indent | SC_FOLDLEVELWHITEFLAG; + else + return indent; +} + +void DocumentAccessor::IndicatorFill(int start, int end, int indicator, int value) { + pdoc->decorations.SetCurrentIndicator(indicator); + pdoc->DecorationFillRange(start, value, end - start); +} diff --git a/sdk/wxscintilla/src/scintilla/src/DocumentAccessor.h b/sdk/wxscintilla/src/scintilla/src/DocumentAccessor.h new file mode 100644 index 0000000..c7af142 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/DocumentAccessor.h @@ -0,0 +1,77 @@ +// Scintilla source code edit control +/** @file DocumentAccessor.h + ** Implementation of BufferAccess and StylingAccess on a Scintilla + ** rapid easy access to contents of a Scintilla. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +class Document; + +/** + */ + +class DocumentAccessor : public Accessor { + // Private so DocumentAccessor objects can not be copied + DocumentAccessor(const DocumentAccessor &source); + DocumentAccessor &operator=(const DocumentAccessor &); + +protected: + Document *pdoc; + PropertyGet &props; + WindowID id; + int lenDoc; + + char styleBuf[bufferSize]; + int validLen; + char chFlags; + char chWhile; + unsigned int startSeg; + int startPosStyling; + int mask; + + bool InternalIsLeadByte(char ch); + void Fill(int position); + +public: + DocumentAccessor(Document *pdoc_, PropertyGet &props_, WindowID id_=0) : + Accessor(), pdoc(pdoc_), props(props_), id(id_), + lenDoc(-1), validLen(0), chFlags(0), chWhile(0), + startSeg(0), startPosStyling(0), + mask(127) { // Initialize the mask to be big enough for any lexer. + } + ~DocumentAccessor(); + bool Match(int pos, const char *s); + char StyleAt(int position); + int GetLine(int position); + int LineStart(int line); + int LevelAt(int line); + int Length(); + void Flush(); + int GetLineState(int line); + int SetLineState(int line, int state); + int GetPropertyInt(const char *key, int defaultValue=0) { + return props.GetInt(key, defaultValue); + } + char *GetProperties() { + return props.ToString(); + } + WindowID GetWindow() { return id; } + + void StartAt(unsigned int start, char chMask=31); + void SetFlags(char chFlags_, char chWhile_) {chFlags = chFlags_; chWhile = chWhile_; } + unsigned int GetStartSegment() { return startSeg; } + void StartSegment(unsigned int pos); + void ColourTo(unsigned int pos, int chAttr); + void SetLevel(int line, int level); + int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0); + void IndicatorFill(int start, int end, int indicator, int value); +}; + +#ifdef SCI_NAMESPACE +} +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/Editor.cxx b/sdk/wxscintilla/src/scintilla/src/Editor.cxx new file mode 100644 index 0000000..8bf418e --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Editor.cxx @@ -0,0 +1,8708 @@ +// Scintilla source code edit control +/** @file Editor.cxx + ** Main code for the edit control. + **/ +// Copyright 1998-2004 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include +#include +#include +#include + +// With Borland C++ 5.5, including includes Windows.h leading to defining +// FindText to FindTextA which makes calls here to Document::FindText fail. +#ifdef __BORLANDC__ +#ifdef FindText +#undef FindText +#endif +#endif + +#include "Platform.h" + +#include "Scintilla.h" + +#include "SplitVector.h" +#include "Partitioning.h" +#include "RunStyles.h" +#include "ContractionState.h" +#include "CellBuffer.h" +#include "KeyMap.h" +#include "Indicator.h" +#include "XPM.h" +#include "LineMarker.h" +#include "Style.h" +#include "ViewStyle.h" +#include "CharClassify.h" +#include "Decoration.h" +#include "Document.h" +#include "Selection.h" +#include "PositionCache.h" +#include "Editor.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +/* + return whether this modification represents an operation that + may reasonably be deferred (not done now OR [possibly] at all) +*/ +static bool CanDeferToLastStep(const DocModification& mh) { + if (mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE)) + return true; // CAN skip + if (!(mh.modificationType & (SC_PERFORMED_UNDO | SC_PERFORMED_REDO))) + return false; // MUST do + if (mh.modificationType & SC_MULTISTEPUNDOREDO) + return true; // CAN skip + return false; // PRESUMABLY must do +} + +static bool CanEliminate(const DocModification& mh) { + return + (mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE)) != 0; +} + +/* + return whether this modification represents the FINAL step + in a [possibly lengthy] multi-step Undo/Redo sequence +*/ +static bool IsLastStep(const DocModification& mh) { + return + (mh.modificationType & (SC_PERFORMED_UNDO | SC_PERFORMED_REDO)) != 0 + && (mh.modificationType & SC_MULTISTEPUNDOREDO) != 0 + && (mh.modificationType & SC_LASTSTEPINUNDOREDO) != 0 + && (mh.modificationType & SC_MULTILINEUNDOREDO) != 0; +} + +Caret::Caret() : + active(false), on(false), period(500) {} + +Timer::Timer() : + ticking(false), ticksToWait(0), tickerID(0) {} + +Idler::Idler() : + state(false), idlerID(0) {} + +static inline bool IsControlCharacter(int ch) { + // iscntrl returns true for lots of chars > 127 which are displayable + return ch >= 0 && ch < ' '; +} + +Editor::Editor() { + ctrlID = 0; + + stylesValid = false; + + printMagnification = 0; + printColourMode = SC_PRINT_NORMAL; + printWrapState = eWrapWord; + cursorMode = SC_CURSORNORMAL; + controlCharSymbol = 0; /* Draw the control characters */ + + hasFocus = false; + hideSelection = false; + inOverstrike = false; + errorStatus = 0; + mouseDownCaptures = true; + + bufferedDraw = true; + twoPhaseDraw = true; + + lastClickTime = 0; + dwellDelay = SC_TIME_FOREVER; + ticksToDwell = SC_TIME_FOREVER; + dwelling = false; + ptMouseLast.x = 0; + ptMouseLast.y = 0; + inDragDrop = ddNone; + dropWentOutside = false; + posDrag = SelectionPosition(invalidPosition); + posDrop = SelectionPosition(invalidPosition); + selectionType = selChar; + + lastXChosen = 0; + lineAnchor = 0; + originalAnchorPos = 0; + + primarySelection = true; + + caretXPolicy = CARET_SLOP | CARET_EVEN; + caretXSlop = 50; + + caretYPolicy = CARET_EVEN; + caretYSlop = 0; + + searchAnchor = 0; + + xOffset = 0; + xCaretMargin = 50; + horizontalScrollBarVisible = true; + scrollWidth = 2000; + trackLineWidth = false; + lineWidthMaxSeen = 0; + verticalScrollBarVisible = true; + endAtLastLine = true; + caretSticky = false; + multipleSelection = false; + additionalSelectionTyping = false; + multiPasteMode = SC_MULTIPASTE_ONCE; + additionalCaretsBlink = true; + additionalCaretsVisible = true; + virtualSpaceOptions = SCVS_NONE; + + pixmapLine = Surface::Allocate(); + pixmapSelMargin = Surface::Allocate(); + pixmapSelPattern = Surface::Allocate(); + pixmapIndentGuide = Surface::Allocate(); + pixmapIndentGuideHighlight = Surface::Allocate(); + + targetStart = 0; + targetEnd = 0; + searchFlags = 0; + + topLine = 0; + posTopLine = 0; + + lengthForEncode = -1; + + needUpdateUI = true; + braces[0] = invalidPosition; + braces[1] = invalidPosition; + bracesMatchStyle = STYLE_BRACEBAD; + highlightGuideColumn = 0; + + theEdge = 0; + + paintState = notPainting; + + modEventMask = SC_MODEVENTMASKALL; + + pdoc = new Document(); + pdoc->AddRef(); + pdoc->AddWatcher(this, 0); + + recordingMacro = false; + foldFlags = 0; + + wrapState = eWrapNone; + wrapWidth = LineLayout::wrapWidthInfinite; + wrapStart = wrapLineLarge; + wrapEnd = wrapLineLarge; + wrapVisualFlags = 0; + wrapVisualFlagsLocation = 0; + wrapVisualStartIndent = 0; + wrapIndentMode = SC_WRAPINDENT_FIXED; + wrapAddIndent = 0; + + convertPastes = true; + + hsStart = -1; + hsEnd = -1; + + llc.SetLevel(LineLayoutCache::llcCaret); + posCache.SetSize(0x400); +} + +Editor::~Editor() { + pdoc->RemoveWatcher(this, 0); + pdoc->Release(); + pdoc = 0; + DropGraphics(); + delete pixmapLine; + delete pixmapSelMargin; + delete pixmapSelPattern; + delete pixmapIndentGuide; + delete pixmapIndentGuideHighlight; +} + +void Editor::Finalise() { + SetIdle(false); + CancelModes(); +} + +void Editor::DropGraphics() { + pixmapLine->Release(); + pixmapSelMargin->Release(); + pixmapSelPattern->Release(); + pixmapIndentGuide->Release(); + pixmapIndentGuideHighlight->Release(); +} + +void Editor::InvalidateStyleData() { + stylesValid = false; + DropGraphics(); + palette.Release(); + llc.Invalidate(LineLayout::llInvalid); + posCache.Clear(); +} + +void Editor::InvalidateStyleRedraw() { + NeedWrapping(); + InvalidateStyleData(); + Redraw(); +} + +void Editor::RefreshColourPalette(Palette &pal, bool want) { + vs.RefreshColourPalette(pal, want); +} + +void Editor::RefreshStyleData() { + if (!stylesValid) { + stylesValid = true; + AutoSurface surface(this); + if (surface) { + vs.Refresh(*surface); + RefreshColourPalette(palette, true); + palette.Allocate(wMain); + RefreshColourPalette(palette, false); + } + if (wrapIndentMode == SC_WRAPINDENT_INDENT) { + wrapAddIndent = pdoc->IndentSize() * vs.spaceWidth; + } else if (wrapIndentMode == SC_WRAPINDENT_SAME) { + wrapAddIndent = 0; + } else { //SC_WRAPINDENT_FIXED + wrapAddIndent = wrapVisualStartIndent * vs.aveCharWidth; + if ((wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (wrapAddIndent <= 0)) + wrapAddIndent = vs.aveCharWidth; // must indent to show start visual + } + SetScrollBars(); + SetRectangularRange(); + } +} + +PRectangle Editor::GetClientRectangle() { + return wMain.GetClientPosition(); +} + +PRectangle Editor::GetTextRectangle() { + PRectangle rc = GetClientRectangle(); + rc.left += vs.fixedColumnWidth; + rc.right -= vs.rightMarginWidth; + return rc; +} + +int Editor::LinesOnScreen() { + PRectangle rcClient = GetClientRectangle(); + int htClient = rcClient.bottom - rcClient.top; + //Platform::DebugPrintf("lines on screen = %d\n", htClient / lineHeight + 1); + return htClient / vs.lineHeight; +} + +int Editor::LinesToScroll() { + int retVal = LinesOnScreen() - 1; + if (retVal < 1) + return 1; + else + return retVal; +} + +int Editor::MaxScrollPos() { + //Platform::DebugPrintf("Lines %d screen = %d maxScroll = %d\n", + //LinesTotal(), LinesOnScreen(), LinesTotal() - LinesOnScreen() + 1); + int retVal = cs.LinesDisplayed(); + if (endAtLastLine) { + retVal -= LinesOnScreen(); + } else { + retVal--; + } + if (retVal < 0) { + return 0; + } else { + return retVal; + } +} + +const char *ControlCharacterString(unsigned char ch) { + const char *reps[] = { + "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", + "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI", + "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB", + "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US" + }; + if (ch < (sizeof(reps) / sizeof(reps[0]))) { + return reps[ch]; + } else { + return "BAD"; + } +} + +/** + * Convenience class to ensure LineLayout objects are always disposed. + */ +class AutoLineLayout { + LineLayoutCache &llc; + LineLayout *ll; + AutoLineLayout &operator=(const AutoLineLayout &); +public: + AutoLineLayout(LineLayoutCache &llc_, LineLayout *ll_) : llc(llc_), ll(ll_) {} + ~AutoLineLayout() { + llc.Dispose(ll); + ll = 0; + } + LineLayout *operator->() const { + return ll; + } + operator LineLayout *() const { + return ll; + } + void Set(LineLayout *ll_) { + llc.Dispose(ll); + ll = ll_; + } +}; + +SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const { + if (sp.Position() < 0) { + return SelectionPosition(0); + } else if (sp.Position() > pdoc->Length()) { + return SelectionPosition(pdoc->Length()); + } else { + // If not at end of line then set offset to 0 + if (!pdoc->IsLineEndPosition(sp.Position())) + sp.SetVirtualSpace(0); + return sp; + } +} + +Point Editor::LocationFromPosition(SelectionPosition pos) { + Point pt; + RefreshStyleData(); + if (pos.Position() == INVALID_POSITION) + return pt; + int line = pdoc->LineFromPosition(pos.Position()); + int lineVisible = cs.DisplayFromDoc(line); + //Platform::DebugPrintf("line=%d\n", line); + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(line)); + if (surface && ll) { + // -1 because of adding in for visible lines in following loop. + pt.y = (lineVisible - topLine - 1) * vs.lineHeight; + pt.x = 0; + unsigned int posLineStart = pdoc->LineStart(line); + LayoutLine(line, surface, vs, ll, wrapWidth); + int posInLine = pos.Position() - posLineStart; + // In case of very long line put x at arbitrary large position + if (posInLine > ll->maxLineLength) { + pt.x = ll->positions[ll->maxLineLength] - ll->positions[ll->LineStart(ll->lines)]; + } + + for (int subLine = 0; subLine < ll->lines; subLine++) { + if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) { + pt.x = ll->positions[posInLine] - ll->positions[ll->LineStart(subLine)]; + if (ll->wrapIndent != 0) { + int lineStart = ll->LineStart(subLine); + if (lineStart != 0) // Wrapped + pt.x += ll->wrapIndent; + } + } + if (posInLine >= ll->LineStart(subLine)) { + pt.y += vs.lineHeight; + } + } + pt.x += vs.fixedColumnWidth - xOffset; + } + pt.x += pos.VirtualSpace() * static_cast(vs.styles[ll->EndLineStyle()].spaceWidth); + return pt; +} + +Point Editor::LocationFromPosition(int pos) { + return LocationFromPosition(SelectionPosition(pos)); +} + +int Editor::XFromPosition(int pos) { + Point pt = LocationFromPosition(pos); + return pt.x - vs.fixedColumnWidth + xOffset; +} + +int Editor::XFromPosition(SelectionPosition sp) { + Point pt = LocationFromPosition(sp); + return pt.x - vs.fixedColumnWidth + xOffset; +} + +int Editor::LineFromLocation(Point pt) { + return cs.DocFromDisplay(pt.y / vs.lineHeight + topLine); +} + +void Editor::SetTopLine(int topLineNew) { + topLine = topLineNew; + posTopLine = pdoc->LineStart(cs.DocFromDisplay(topLine)); +} + +SelectionPosition Editor::SPositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition, bool virtualSpace) { + RefreshStyleData(); + if (canReturnInvalid) { + PRectangle rcClient = GetTextRectangle(); + if (!rcClient.Contains(pt)) + return SelectionPosition(INVALID_POSITION); + if (pt.x < vs.fixedColumnWidth) + return SelectionPosition(INVALID_POSITION); + if (pt.y < 0) + return SelectionPosition(INVALID_POSITION); + } + pt.x = pt.x - vs.fixedColumnWidth + xOffset; + int visibleLine = pt.y / vs.lineHeight + topLine; + if (pt.y < 0) { // Division rounds towards 0 + visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine; + } + if (!canReturnInvalid && (visibleLine < 0)) + visibleLine = 0; + int lineDoc = cs.DocFromDisplay(visibleLine); + if (canReturnInvalid && (lineDoc < 0)) + return SelectionPosition(INVALID_POSITION); + if (lineDoc >= pdoc->LinesTotal()) + return SelectionPosition(canReturnInvalid ? INVALID_POSITION : pdoc->Length()); + unsigned int posLineStart = pdoc->LineStart(lineDoc); + SelectionPosition retVal(canReturnInvalid ? INVALID_POSITION : static_cast(posLineStart)); + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc)); + if (surface && ll) { + LayoutLine(lineDoc, surface, vs, ll, wrapWidth); + int lineStartSet = cs.DisplayFromDoc(lineDoc); + int subLine = visibleLine - lineStartSet; + if (subLine < ll->lines) { + int lineStart = ll->LineStart(subLine); + int lineEnd = ll->LineLastVisible(subLine); + int subLineStart = ll->positions[lineStart]; + + if (ll->wrapIndent != 0) { + if (lineStart != 0) // Wrapped + pt.x -= ll->wrapIndent; + } + int i = ll->FindBefore(pt.x + subLineStart, lineStart, lineEnd); + while (i < lineEnd) { + if (charPosition) { + if ((pt.x + subLineStart) < (ll->positions[i + 1])) { + return SelectionPosition(pdoc->MovePositionOutsideChar(i + posLineStart, 1)); + } + } else { + if ((pt.x + subLineStart) < ((ll->positions[i] + ll->positions[i + 1]) / 2)) { + return SelectionPosition(pdoc->MovePositionOutsideChar(i + posLineStart, 1)); + } + } + i++; + } + if (virtualSpace) { + const int spaceWidth = static_cast(vs.styles[ll->EndLineStyle()].spaceWidth); + int spaceOffset = (pt.x + subLineStart - ll->positions[lineEnd] + spaceWidth / 2) / + spaceWidth; + return SelectionPosition(lineEnd + posLineStart, spaceOffset); + } else if (canReturnInvalid) { + if (pt.x < (ll->positions[lineEnd] - subLineStart)) { + return SelectionPosition(pdoc->MovePositionOutsideChar(lineEnd + posLineStart, 1)); + } + } else { + return SelectionPosition(lineEnd + posLineStart); + } + } + if (!canReturnInvalid) + return SelectionPosition(ll->numCharsInLine + posLineStart); + } + return retVal; +} + +int Editor::PositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition) { + return SPositionFromLocation(pt, canReturnInvalid, charPosition, false).Position(); +} + +/** + * Find the document position corresponding to an x coordinate on a particular document line. + * Ensure is between whole characters when document is in multi-byte or UTF-8 mode. + */ +int Editor::PositionFromLineX(int lineDoc, int x) { + RefreshStyleData(); + if (lineDoc >= pdoc->LinesTotal()) + return pdoc->Length(); + //Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine); + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc)); + int retVal = 0; + if (surface && ll) { + unsigned int posLineStart = pdoc->LineStart(lineDoc); + LayoutLine(lineDoc, surface, vs, ll, wrapWidth); + retVal = ll->numCharsBeforeEOL + posLineStart; + int subLine = 0; + int lineStart = ll->LineStart(subLine); + int lineEnd = ll->LineLastVisible(subLine); + int subLineStart = ll->positions[lineStart]; + + if (ll->wrapIndent != 0) { + if (lineStart != 0) // Wrapped + x -= ll->wrapIndent; + } + int i = ll->FindBefore(x + subLineStart, lineStart, lineEnd); + while (i < lineEnd) { + if ((x + subLineStart) < ((ll->positions[i] + ll->positions[i + 1]) / 2)) { + retVal = pdoc->MovePositionOutsideChar(i + posLineStart, 1); + break; + } + i++; + } + } + return retVal; +} + +/** + * Find the document position corresponding to an x coordinate on a particular document line. + * Ensure is between whole characters when document is in multi-byte or UTF-8 mode. + */ +SelectionPosition Editor::SPositionFromLineX(int lineDoc, int x) { + RefreshStyleData(); + if (lineDoc >= pdoc->LinesTotal()) + return SelectionPosition(pdoc->Length()); + //Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine); + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc)); + int retVal = 0; + if (surface && ll) { + unsigned int posLineStart = pdoc->LineStart(lineDoc); + LayoutLine(lineDoc, surface, vs, ll, wrapWidth); + int subLine = 0; + int lineStart = ll->LineStart(subLine); + int lineEnd = ll->LineLastVisible(subLine); + int subLineStart = ll->positions[lineStart]; + + if (ll->wrapIndent != 0) { + if (lineStart != 0) // Wrapped + x -= ll->wrapIndent; + } + int i = ll->FindBefore(x + subLineStart, lineStart, lineEnd); + while (i < lineEnd) { + if ((x + subLineStart) < ((ll->positions[i] + ll->positions[i + 1]) / 2)) { + retVal = pdoc->MovePositionOutsideChar(i + posLineStart, 1); + return SelectionPosition(retVal); + } + i++; + } + const int spaceWidth = static_cast(vs.styles[ll->EndLineStyle()].spaceWidth); + int spaceOffset = (x + subLineStart - ll->positions[lineEnd] + spaceWidth / 2) / spaceWidth; + return SelectionPosition(lineEnd + posLineStart, spaceOffset); + } + return SelectionPosition(retVal); +} + +/** + * If painting then abandon the painting because a wider redraw is needed. + * @return true if calling code should stop drawing. + */ +bool Editor::AbandonPaint() { + if ((paintState == painting) && !paintingAllText) { + paintState = paintAbandoned; + } + return paintState == paintAbandoned; +} + +void Editor::RedrawRect(PRectangle rc) { + //Platform::DebugPrintf("Redraw %0d,%0d - %0d,%0d\n", rc.left, rc.top, rc.right, rc.bottom); + + // Clip the redraw rectangle into the client area + PRectangle rcClient = GetClientRectangle(); + if (rc.top < rcClient.top) + rc.top = rcClient.top; + if (rc.bottom > rcClient.bottom) + rc.bottom = rcClient.bottom; + if (rc.left < rcClient.left) + rc.left = rcClient.left; + if (rc.right > rcClient.right) + rc.right = rcClient.right; + + if ((rc.bottom > rc.top) && (rc.right > rc.left)) { + wMain.InvalidateRectangle(rc); + } +} + +void Editor::Redraw() { + //Platform::DebugPrintf("Redraw all\n"); + PRectangle rcClient = GetClientRectangle(); + wMain.InvalidateRectangle(rcClient); + //wMain.InvalidateAll(); +} + +void Editor::RedrawSelMargin(int line, bool allAfter) { + if (!AbandonPaint()) { + if (vs.maskInLine) { + Redraw(); + } else { + PRectangle rcSelMargin = GetClientRectangle(); + rcSelMargin.right = vs.fixedColumnWidth; + if (line != -1) { + int position = pdoc->LineStart(line); + PRectangle rcLine = RectangleFromRange(position, position); + rcSelMargin.top = rcLine.top; + if (!allAfter) + rcSelMargin.bottom = rcLine.bottom; + } + wMain.InvalidateRectangle(rcSelMargin); + } + } +} + +PRectangle Editor::RectangleFromRange(int start, int end) { + int minPos = start; + if (minPos > end) + minPos = end; + int maxPos = start; + if (maxPos < end) + maxPos = end; + int minLine = cs.DisplayFromDoc(pdoc->LineFromPosition(minPos)); + int lineDocMax = pdoc->LineFromPosition(maxPos); + int maxLine = cs.DisplayFromDoc(lineDocMax) + cs.GetHeight(lineDocMax) - 1; + PRectangle rcClient = GetTextRectangle(); + PRectangle rc; + rc.left = vs.fixedColumnWidth; + rc.top = (minLine - topLine) * vs.lineHeight; + if (rc.top < 0) + rc.top = 0; + rc.right = rcClient.right; + rc.bottom = (maxLine - topLine + 1) * vs.lineHeight; + // Ensure PRectangle is within 16 bit space + rc.top = Platform::Clamp(rc.top, -32000, 32000); + rc.bottom = Platform::Clamp(rc.bottom, -32000, 32000); + + return rc; +} + +void Editor::InvalidateRange(int start, int end) { + RedrawRect(RectangleFromRange(start, end)); +} + +int Editor::CurrentPosition() { + return sel.MainCaret(); +} + +bool Editor::SelectionEmpty() { + return sel.Empty(); +} + +SelectionPosition Editor::SelectionStart() { + return sel.RangeMain().Start(); +} + +SelectionPosition Editor::SelectionEnd() { + return sel.RangeMain().End(); +} + +void Editor::SetRectangularRange() { + if (sel.IsRectangular()) { + int xAnchor = XFromPosition(sel.Rectangular().anchor); + int xCaret = XFromPosition(sel.Rectangular().caret); + if (sel.selType == Selection::selThin) { + xCaret = xAnchor; + } + int lineAnchor = pdoc->LineFromPosition(sel.Rectangular().anchor.Position()); + int lineCaret = pdoc->LineFromPosition(sel.Rectangular().caret.Position()); + int increment = (lineCaret > lineAnchor) ? 1 : -1; + for (int line=lineAnchor; line != lineCaret+increment; line += increment) { + SelectionRange range(SPositionFromLineX(line, xCaret), SPositionFromLineX(line, xAnchor)); + if ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) == 0) + range.ClearVirtualSpace(); + if (line == lineAnchor) + sel.SetSelection(range); + else + sel.AddSelection(range); + } + } +} + +void Editor::ThinRectangularRange() { + if (sel.IsRectangular()) { + sel.selType = Selection::selThin; + if (sel.Rectangular().caret < sel.Rectangular().anchor) { + sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).caret, sel.Range(0).anchor); + } else { + sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).anchor, sel.Range(0).caret); + } + SetRectangularRange(); + } +} + +void Editor::InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection) { + if (sel.Count() > 1 || !(sel.RangeMain().anchor == newMain.anchor) || sel.IsRectangular()) { + invalidateWholeSelection = true; + } + int firstAffected = Platform::Minimum(sel.RangeMain().Start().Position(), newMain.Start().Position()); + // +1 for lastAffected ensures caret repainted + int lastAffected = Platform::Maximum(newMain.caret.Position()+1, newMain.anchor.Position()); + lastAffected = Platform::Maximum(lastAffected, sel.RangeMain().End().Position()); + if (invalidateWholeSelection) { + for (size_t r=0; r 1 || !(sel.RangeMain() == rangeNew)) { + InvalidateSelection(rangeNew); + } + sel.RangeMain() = rangeNew; + SetRectangularRange(); + ClaimSelection(); +} + +void Editor::SetSelection(int currentPos_, int anchor_) { + SetSelection(SelectionPosition(currentPos_), SelectionPosition(anchor_)); +} + +// Just move the caret on the main selection +void Editor::SetSelection(SelectionPosition currentPos_) { + currentPos_ = ClampPositionIntoDocument(currentPos_); + if (sel.Count() > 1 || !(sel.RangeMain().caret == currentPos_)) { + InvalidateSelection(SelectionRange(currentPos_)); + } + if (sel.IsRectangular()) { + sel.Rectangular() = + SelectionRange(SelectionPosition(currentPos_), sel.Rectangular().anchor); + SetRectangularRange(); + } else { + sel.RangeMain() = + SelectionRange(SelectionPosition(currentPos_), sel.RangeMain().anchor); + } + ClaimSelection(); +} + +void Editor::SetSelection(int currentPos_) { + SetSelection(SelectionPosition(currentPos_)); +} + +void Editor::SetEmptySelection(SelectionPosition currentPos_) { + SelectionRange rangeNew(ClampPositionIntoDocument(currentPos_)); + if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) { + InvalidateSelection(rangeNew); + } + sel.Clear(); + sel.RangeMain() = rangeNew; + SetRectangularRange(); + ClaimSelection(); + +} + +void Editor::SetEmptySelection(int currentPos_) { + SetEmptySelection(SelectionPosition(currentPos_)); +} + +bool Editor::RangeContainsProtected(int start, int end) const { + if (vs.ProtectionActive()) { + if (start > end) { + int t = start; + start = end; + end = t; + } + int mask = pdoc->stylingBitsMask; + for (int pos = start; pos < end; pos++) { + if (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected()) + return true; + } + } + return false; +} + +bool Editor::SelectionContainsProtected() { + for (size_t r=0; rMovePositionOutsideChar(pos.Position(), moveDir, checkLineEnd); + if (posMoved != pos.Position()) + pos.SetPosition(posMoved); + if (vs.ProtectionActive()) { + int mask = pdoc->stylingBitsMask; + if (moveDir > 0) { + if ((pos.Position() > 0) && vs.styles[pdoc->StyleAt(pos.Position() - 1) & mask].IsProtected()) { + while ((pos.Position() < pdoc->Length()) && + (vs.styles[pdoc->StyleAt(pos.Position()) & mask].IsProtected())) + pos.Add(1); + } + } else if (moveDir < 0) { + if (vs.styles[pdoc->StyleAt(pos.Position()) & mask].IsProtected()) { + while ((pos.Position() > 0) && + (vs.styles[pdoc->StyleAt(pos.Position() - 1) & mask].IsProtected())) + pos.Add(-1); + } + } + } + return pos; +} + +int Editor::MovePositionTo(SelectionPosition newPos, Selection::selTypes selt, bool ensureVisible) { + bool simpleCaret = (sel.Count() == 1) && sel.Empty(); + SelectionPosition spCaret = sel.Last(); + + int delta = newPos.Position() - sel.MainCaret(); + newPos = ClampPositionIntoDocument(newPos); + newPos = MovePositionOutsideChar(newPos, delta); + if (!multipleSelection && sel.IsRectangular() && (selt == Selection::selStream)) { + // Can't turn into multiple selection so clear additional selections + InvalidateSelection(SelectionRange(newPos), true); + SelectionRange rangeMain = sel.RangeMain(); + sel.SetSelection(rangeMain); + } + if (!sel.IsRectangular() && (selt == Selection::selRectangle)) { + // Switching to rectangular + SelectionRange rangeMain = sel.RangeMain(); + sel.Clear(); + sel.Rectangular() = rangeMain; + } + if (selt != Selection::noSel) { + sel.selType = selt; + } + if (selt != Selection::noSel || sel.MoveExtends()) { + SetSelection(newPos); + } else { + SetEmptySelection(newPos); + } + ShowCaretAtCurrentPosition(); + if (ensureVisible) { + XYScrollPosition newXY = XYScrollToMakeVisible(true, true, true); + if (simpleCaret && (newXY.xOffset == xOffset)) { + // simple vertical scroll then invalidate + ScrollTo(newXY.topLine); + InvalidateSelection(SelectionRange(spCaret), true); + } else { + SetXYScroll(newXY); + } + } + return 0; +} + +int Editor::MovePositionTo(int newPos, Selection::selTypes selt, bool ensureVisible) { + return MovePositionTo(SelectionPosition(newPos), selt, ensureVisible); +} + +SelectionPosition Editor::MovePositionSoVisible(SelectionPosition pos, int moveDir) { + pos = ClampPositionIntoDocument(pos); + pos = MovePositionOutsideChar(pos, moveDir); + int lineDoc = pdoc->LineFromPosition(pos.Position()); + if (cs.GetVisible(lineDoc)) { + return pos; + } else { + int lineDisplay = cs.DisplayFromDoc(lineDoc); + if (moveDir > 0) { + // lineDisplay is already line before fold as lines in fold use display line of line after fold + lineDisplay = Platform::Clamp(lineDisplay, 0, cs.LinesDisplayed()); + return SelectionPosition(pdoc->LineStart(cs.DocFromDisplay(lineDisplay))); + } else { + lineDisplay = Platform::Clamp(lineDisplay - 1, 0, cs.LinesDisplayed()); + return SelectionPosition(pdoc->LineEnd(cs.DocFromDisplay(lineDisplay))); + } + } +} + +SelectionPosition Editor::MovePositionSoVisible(int pos, int moveDir) { + return MovePositionSoVisible(SelectionPosition(pos), moveDir); +} + +Point Editor::PointMainCaret() { + return LocationFromPosition(sel.Range(sel.Main()).caret); +} + +/** + * Choose the x position that the caret will try to stick to + * as it moves up and down. + */ +void Editor::SetLastXChosen() { + Point pt = PointMainCaret(); + lastXChosen = pt.x + xOffset; +} + +void Editor::ScrollTo(int line, bool moveThumb) { + int topLineNew = Platform::Clamp(line, 0, MaxScrollPos()); + if (topLineNew != topLine) { + // Try to optimise small scrolls + int linesToMove = topLine - topLineNew; + SetTopLine(topLineNew); + // Optimize by styling the view as this will invalidate any needed area + // which could abort the initial paint if discovered later. + StyleToPositionInView(PositionAfterArea(GetClientRectangle())); +#ifndef UNDER_CE + // Perform redraw rather than scroll if many lines would be redrawn anyway. + if ((abs(linesToMove) <= 10) && (paintState == notPainting)) { + ScrollText(linesToMove); + } else { + Redraw(); + } +#else + Redraw(); +#endif + if (moveThumb) { + SetVerticalScrollPos(); + } + } +} + +void Editor::ScrollText(int /* linesToMove */) { + //Platform::DebugPrintf("Editor::ScrollText %d\n", linesToMove); + Redraw(); +} + +void Editor::HorizontalScrollTo(int xPos) { + //Platform::DebugPrintf("HorizontalScroll %d\n", xPos); + if (xPos < 0) + xPos = 0; + if ((wrapState == eWrapNone) && (xOffset != xPos)) { + xOffset = xPos; + SetHorizontalScrollPos(); + RedrawRect(GetClientRectangle()); + } +} + +void Editor::MoveCaretInsideView(bool ensureVisible) { + PRectangle rcClient = GetTextRectangle(); + Point pt = PointMainCaret(); + if (pt.y < rcClient.top) { + MovePositionTo(SPositionFromLocation( + Point(lastXChosen - xOffset, rcClient.top)), + Selection::noSel, ensureVisible); + } else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) { + int yOfLastLineFullyDisplayed = rcClient.top + (LinesOnScreen() - 1) * vs.lineHeight; + MovePositionTo(SPositionFromLocation( + Point(lastXChosen - xOffset, rcClient.top + yOfLastLineFullyDisplayed)), + Selection::noSel, ensureVisible); + } +} + +int Editor::DisplayFromPosition(int pos) { + int lineDoc = pdoc->LineFromPosition(pos); + int lineDisplay = cs.DisplayFromDoc(lineDoc); + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc)); + if (surface && ll) { + LayoutLine(lineDoc, surface, vs, ll, wrapWidth); + unsigned int posLineStart = pdoc->LineStart(lineDoc); + int posInLine = pos - posLineStart; + lineDisplay--; // To make up for first increment ahead. + for (int subLine = 0; subLine < ll->lines; subLine++) { + if (posInLine >= ll->LineStart(subLine)) { + lineDisplay++; + } + } + } + return lineDisplay; +} + +/** + * Ensure the caret is reasonably visible in context. + * +Caret policy in SciTE + +If slop is set, we can define a slop value. +This value defines an unwanted zone (UZ) where the caret is... unwanted. +This zone is defined as a number of pixels near the vertical margins, +and as a number of lines near the horizontal margins. +By keeping the caret away from the edges, it is seen within its context, +so it is likely that the identifier that the caret is on can be completely seen, +and that the current line is seen with some of the lines following it which are +often dependent on that line. + +If strict is set, the policy is enforced... strictly. +The caret is centred on the display if slop is not set, +and cannot go in the UZ if slop is set. + +If jumps is set, the display is moved more energetically +so the caret can move in the same direction longer before the policy is applied again. +'3UZ' notation is used to indicate three time the size of the UZ as a distance to the margin. + +If even is not set, instead of having symmetrical UZs, +the left and bottom UZs are extended up to right and top UZs respectively. +This way, we favour the displaying of useful information: the begining of lines, +where most code reside, and the lines after the caret, eg. the body of a function. + + | | | | | +slop | strict | jumps | even | Caret can go to the margin | When reaching limit (caret going out of + | | | | | visibility or going into the UZ) display is... +-----+--------+-------+------+--------------------------------------------+-------------------------------------------------------------- + 0 | 0 | 0 | 0 | Yes | moved to put caret on top/on right + 0 | 0 | 0 | 1 | Yes | moved by one position + 0 | 0 | 1 | 0 | Yes | moved to put caret on top/on right + 0 | 0 | 1 | 1 | Yes | centred on the caret + 0 | 1 | - | 0 | Caret is always on top/on right of display | - + 0 | 1 | - | 1 | No, caret is always centred | - + 1 | 0 | 0 | 0 | Yes | moved to put caret out of the asymmetrical UZ + 1 | 0 | 0 | 1 | Yes | moved to put caret out of the UZ + 1 | 0 | 1 | 0 | Yes | moved to put caret at 3UZ of the top or right margin + 1 | 0 | 1 | 1 | Yes | moved to put caret at 3UZ of the margin + 1 | 1 | - | 0 | Caret is always at UZ of top/right margin | - + 1 | 1 | 0 | 1 | No, kept out of UZ | moved by one position + 1 | 1 | 1 | 1 | No, kept out of UZ | moved to put caret at 3UZ of the margin +*/ + +Editor::XYScrollPosition Editor::XYScrollToMakeVisible(const bool useMargin, const bool vert, const bool horiz) { + PRectangle rcClient = GetTextRectangle(); + const SelectionPosition posCaret = posDrag.IsValid() ? posDrag : sel.RangeMain().caret; + const Point pt = LocationFromPosition(posCaret); + const Point ptBottomCaret(pt.x, pt.y + vs.lineHeight - 1); + const int lineCaret = DisplayFromPosition(posCaret.Position()); + + XYScrollPosition newXY(xOffset, topLine); + + // Vertical positioning + if (vert && (pt.y < rcClient.top || ptBottomCaret.y > rcClient.bottom || (caretYPolicy & CARET_STRICT) != 0)) { + const int linesOnScreen = LinesOnScreen(); + const int halfScreen = Platform::Maximum(linesOnScreen - 1, 2) / 2; + const bool bSlop = (caretYPolicy & CARET_SLOP) != 0; + const bool bStrict = (caretYPolicy & CARET_STRICT) != 0; + const bool bJump = (caretYPolicy & CARET_JUMPS) != 0; + const bool bEven = (caretYPolicy & CARET_EVEN) != 0; + + // It should be possible to scroll the window to show the caret, + // but this fails to remove the caret on GTK+ + if (bSlop) { // A margin is defined + int yMoveT, yMoveB; + if (bStrict) { + int yMarginT, yMarginB; + if (!useMargin) { + // In drag mode, avoid moves + // otherwise, a double click will select several lines. + yMarginT = yMarginB = 0; + } else { + // yMarginT must equal to caretYSlop, with a minimum of 1 and + // a maximum of slightly less than half the heigth of the text area. + yMarginT = Platform::Clamp(caretYSlop, 1, halfScreen); + if (bEven) { + yMarginB = yMarginT; + } else { + yMarginB = linesOnScreen - yMarginT - 1; + } + } + yMoveT = yMarginT; + if (bEven) { + if (bJump) { + yMoveT = Platform::Clamp(caretYSlop * 3, 1, halfScreen); + } + yMoveB = yMoveT; + } else { + yMoveB = linesOnScreen - yMoveT - 1; + } + if (lineCaret < topLine + yMarginT) { + // Caret goes too high + newXY.topLine = lineCaret - yMoveT; + } else if (lineCaret > topLine + linesOnScreen - 1 - yMarginB) { + // Caret goes too low + newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB; + } + } else { // Not strict + yMoveT = bJump ? caretYSlop * 3 : caretYSlop; + yMoveT = Platform::Clamp(yMoveT, 1, halfScreen); + if (bEven) { + yMoveB = yMoveT; + } else { + yMoveB = linesOnScreen - yMoveT - 1; + } + if (lineCaret < topLine) { + // Caret goes too high + newXY.topLine = lineCaret - yMoveT; + } else if (lineCaret > topLine + linesOnScreen - 1) { + // Caret goes too low + newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB; + } + } + } else { // No slop + if (!bStrict && !bJump) { + // Minimal move + if (lineCaret < topLine) { + // Caret goes too high + newXY.topLine = lineCaret; + } else if (lineCaret > topLine + linesOnScreen - 1) { + // Caret goes too low + if (bEven) { + newXY.topLine = lineCaret - linesOnScreen + 1; + } else { + newXY.topLine = lineCaret; + } + } + } else { // Strict or going out of display + if (bEven) { + // Always center caret + newXY.topLine = lineCaret - halfScreen; + } else { + // Always put caret on top of display + newXY.topLine = lineCaret; + } + } + } + newXY.topLine = Platform::Clamp(newXY.topLine, 0, MaxScrollPos()); + } + + // Horizontal positioning + if (horiz && (wrapState == eWrapNone)) { + const int halfScreen = Platform::Maximum(rcClient.Width() - 4, 4) / 2; + const bool bSlop = (caretXPolicy & CARET_SLOP) != 0; + const bool bStrict = (caretXPolicy & CARET_STRICT) != 0; + const bool bJump = (caretXPolicy & CARET_JUMPS) != 0; + const bool bEven = (caretXPolicy & CARET_EVEN) != 0; + + if (bSlop) { // A margin is defined + int xMoveL, xMoveR; + if (bStrict) { + int xMarginL, xMarginR; + if (!useMargin) { + // In drag mode, avoid moves unless very near of the margin + // otherwise, a simple click will select text. + xMarginL = xMarginR = 2; + } else { + // xMargin must equal to caretXSlop, with a minimum of 2 and + // a maximum of slightly less than half the width of the text area. + xMarginR = Platform::Clamp(caretXSlop, 2, halfScreen); + if (bEven) { + xMarginL = xMarginR; + } else { + xMarginL = rcClient.Width() - xMarginR - 4; + } + } + if (bJump && bEven) { + // Jump is used only in even mode + xMoveL = xMoveR = Platform::Clamp(caretXSlop * 3, 1, halfScreen); + } else { + xMoveL = xMoveR = 0; // Not used, avoid a warning + } + if (pt.x < rcClient.left + xMarginL) { + // Caret is on the left of the display + if (bJump && bEven) { + newXY.xOffset -= xMoveL; + } else { + // Move just enough to allow to display the caret + newXY.xOffset -= (rcClient.left + xMarginL) - pt.x; + } + } else if (pt.x >= rcClient.right - xMarginR) { + // Caret is on the right of the display + if (bJump && bEven) { + newXY.xOffset += xMoveR; + } else { + // Move just enough to allow to display the caret + newXY.xOffset += pt.x - (rcClient.right - xMarginR) + 1; + } + } + } else { // Not strict + xMoveR = bJump ? caretXSlop * 3 : caretXSlop; + xMoveR = Platform::Clamp(xMoveR, 1, halfScreen); + if (bEven) { + xMoveL = xMoveR; + } else { + xMoveL = rcClient.Width() - xMoveR - 4; + } + if (pt.x < rcClient.left) { + // Caret is on the left of the display + newXY.xOffset -= xMoveL; + } else if (pt.x >= rcClient.right) { + // Caret is on the right of the display + newXY.xOffset += xMoveR; + } + } + } else { // No slop + if (bStrict || + (bJump && (pt.x < rcClient.left || pt.x >= rcClient.right))) { + // Strict or going out of display + if (bEven) { + // Center caret + newXY.xOffset += pt.x - rcClient.left - halfScreen; + } else { + // Put caret on right + newXY.xOffset += pt.x - rcClient.right + 1; + } + } else { + // Move just enough to allow to display the caret + if (pt.x < rcClient.left) { + // Caret is on the left of the display + if (bEven) { + newXY.xOffset -= rcClient.left - pt.x; + } else { + newXY.xOffset += pt.x - rcClient.right + 1; + } + } else if (pt.x >= rcClient.right) { + // Caret is on the right of the display + newXY.xOffset += pt.x - rcClient.right + 1; + } + } + } + // In case of a jump (find result) largely out of display, adjust the offset to display the caret + if (pt.x + xOffset < rcClient.left + newXY.xOffset) { + newXY.xOffset = pt.x + xOffset - rcClient.left; + } else if (pt.x + xOffset >= rcClient.right + newXY.xOffset) { + newXY.xOffset = pt.x + xOffset - rcClient.right + 1; + if (vs.caretStyle == CARETSTYLE_BLOCK) { + // Ensure we can see a good portion of the block caret + newXY.xOffset += vs.aveCharWidth; + } + } + if (newXY.xOffset < 0) { + newXY.xOffset = 0; + } + } + + return newXY; +} + +void Editor::SetXYScroll(XYScrollPosition newXY) { + if ((newXY.topLine != topLine) || (newXY.xOffset != xOffset)) { + if (newXY.topLine != topLine) { + SetTopLine(newXY.topLine); + SetVerticalScrollPos(); + } + if (newXY.xOffset != xOffset) { + xOffset = newXY.xOffset; + if (newXY.xOffset > 0) { + PRectangle rcText = GetTextRectangle(); + if (horizontalScrollBarVisible && + rcText.Width() + xOffset > scrollWidth) { + scrollWidth = xOffset + rcText.Width(); + SetScrollBars(); + } + } + SetHorizontalScrollPos(); + } + Redraw(); + UpdateSystemCaret(); + } + } + +void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) { + SetXYScroll(XYScrollToMakeVisible(useMargin, vert, horiz)); +} + +void Editor::ShowCaretAtCurrentPosition() { + if (hasFocus) { + caret.active = true; + caret.on = true; + SetTicking(true); + } else { + caret.active = false; + caret.on = false; + } + InvalidateCaret(); +} + +void Editor::DropCaret() { + caret.active = false; + InvalidateCaret(); +} + +void Editor::InvalidateCaret() { + if (posDrag.IsValid()) { + InvalidateRange(posDrag.Position(), posDrag.Position() + 1); + } else { + for (size_t r=0; rLinesTotal()); + if (wrapStart > docLineStart) { + wrapStart = docLineStart; + llc.Invalidate(LineLayout::llPositions); + } + if (wrapEnd < docLineEnd) { + wrapEnd = docLineEnd; + } + wrapEnd = Platform::Clamp(wrapEnd, 0, pdoc->LinesTotal()); + // Wrap lines during idle. + if ((wrapState != eWrapNone) && (wrapEnd != wrapStart)) { + SetIdle(true); + } +} + +bool Editor::WrapOneLine(Surface *surface, int lineToWrap) { + AutoLineLayout ll(llc, RetrieveLineLayout(lineToWrap)); + int linesWrapped = 1; + if (ll) { + LayoutLine(lineToWrap, surface, vs, ll, wrapWidth); + linesWrapped = ll->lines; + } + return cs.SetHeight(lineToWrap, linesWrapped + + (vs.annotationVisible ? pdoc->AnnotationLines(lineToWrap) : 0)); +} + +// Check if wrapping needed and perform any needed wrapping. +// fullwrap: if true, all lines which need wrapping will be done, +// in this single call. +// priorityWrapLineStart: If greater than or equal to zero, all lines starting from +// here to 1 page + 100 lines past will be wrapped (even if there are +// more lines under wrapping process in idle). +// If it is neither fullwrap, nor priorityWrap, then 1 page + 100 lines will be +// wrapped, if there are any wrapping going on in idle. (Generally this +// condition is called only from idler). +// Return true if wrapping occurred. +bool Editor::WrapLines(bool fullWrap, int priorityWrapLineStart) { + // If there are any pending wraps, do them during idle if possible. + int linesInOneCall = LinesOnScreen() + 100; + if (wrapState != eWrapNone) { + if (wrapStart < wrapEnd) { + if (!SetIdle(true)) { + // Idle processing not supported so full wrap required. + fullWrap = true; + } + } + if (!fullWrap && priorityWrapLineStart >= 0 && + // .. and if the paint window is outside pending wraps + (((priorityWrapLineStart + linesInOneCall) < wrapStart) || + (priorityWrapLineStart > wrapEnd))) { + // No priority wrap pending + return false; + } + } + int goodTopLine = topLine; + bool wrapOccurred = false; + if (wrapStart <= pdoc->LinesTotal()) { + if (wrapState == eWrapNone) { + if (wrapWidth != LineLayout::wrapWidthInfinite) { + wrapWidth = LineLayout::wrapWidthInfinite; + for (int lineDoc = 0; lineDoc < pdoc->LinesTotal(); lineDoc++) { + cs.SetHeight(lineDoc, 1 + + (vs.annotationVisible ? pdoc->AnnotationLines(lineDoc) : 0)); + } + wrapOccurred = true; + } + wrapStart = wrapLineLarge; + wrapEnd = wrapLineLarge; + } else { + if (wrapEnd >= pdoc->LinesTotal()) + wrapEnd = pdoc->LinesTotal(); + //ElapsedTime et; + int lineDocTop = cs.DocFromDisplay(topLine); + int subLineTop = topLine - cs.DisplayFromDoc(lineDocTop); + PRectangle rcTextArea = GetClientRectangle(); + rcTextArea.left = vs.fixedColumnWidth; + rcTextArea.right -= vs.rightMarginWidth; + wrapWidth = rcTextArea.Width(); + // Ensure all of the document is styled. + pdoc->EnsureStyledTo(pdoc->Length()); + RefreshStyleData(); + AutoSurface surface(this); + if (surface) { + bool priorityWrap = false; + int lastLineToWrap = wrapEnd; + int lineToWrap = wrapStart; + if (!fullWrap) { + if (priorityWrapLineStart >= 0) { + // This is a priority wrap. + lineToWrap = priorityWrapLineStart; + lastLineToWrap = priorityWrapLineStart + linesInOneCall; + priorityWrap = true; + } else { + // This is idle wrap. + lastLineToWrap = wrapStart + linesInOneCall; + } + if (lastLineToWrap >= wrapEnd) + lastLineToWrap = wrapEnd; + } // else do a fullWrap. + + // Platform::DebugPrintf("Wraplines: full = %d, priorityStart = %d (wrapping: %d to %d)\n", fullWrap, priorityWrapLineStart, lineToWrap, lastLineToWrap); + // Platform::DebugPrintf("Pending wraps: %d to %d\n", wrapStart, wrapEnd); + while (lineToWrap < lastLineToWrap) { + if (WrapOneLine(surface, lineToWrap)) { + wrapOccurred = true; + } + lineToWrap++; + } + if (!priorityWrap) + wrapStart = lineToWrap; + // If wrapping is done, bring it to resting position + if (wrapStart >= wrapEnd) { + wrapStart = wrapLineLarge; + wrapEnd = wrapLineLarge; + } + } + goodTopLine = cs.DisplayFromDoc(lineDocTop); + if (subLineTop < cs.GetHeight(lineDocTop)) + goodTopLine += subLineTop; + else + goodTopLine += cs.GetHeight(lineDocTop); + //double durWrap = et.Duration(true); + //Platform::DebugPrintf("Wrap:%9.6g \n", durWrap); + } + } + if (wrapOccurred) { + SetScrollBars(); + SetTopLine(Platform::Clamp(goodTopLine, 0, MaxScrollPos())); + SetVerticalScrollPos(); + } + return wrapOccurred; +} + +void Editor::LinesJoin() { + if (!RangeContainsProtected(targetStart, targetEnd)) { + UndoGroup ug(pdoc); + bool prevNonWS = true; + for (int pos = targetStart; pos < targetEnd; pos++) { + if (IsEOLChar(pdoc->CharAt(pos))) { + targetEnd -= pdoc->LenChar(pos); + pdoc->DelChar(pos); + if (prevNonWS) { + // Ensure at least one space separating previous lines + pdoc->InsertChar(pos, ' '); + targetEnd++; + } + } else { + prevNonWS = pdoc->CharAt(pos) != ' '; + } + } + } +} + +const char *Editor::StringFromEOLMode(int eolMode) { + if (eolMode == SC_EOL_CRLF) { + return "\r\n"; + } else if (eolMode == SC_EOL_CR) { + return "\r"; + } else { + return "\n"; + } +} + +void Editor::LinesSplit(int pixelWidth) { + if (!RangeContainsProtected(targetStart, targetEnd)) { + if (pixelWidth == 0) { + PRectangle rcText = GetTextRectangle(); + pixelWidth = rcText.Width(); + } + int lineStart = pdoc->LineFromPosition(targetStart); + int lineEnd = pdoc->LineFromPosition(targetEnd); + const char *eol = StringFromEOLMode(pdoc->eolMode); + UndoGroup ug(pdoc); + for (int line = lineStart; line <= lineEnd; line++) { + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(line)); + if (surface && ll) { + unsigned int posLineStart = pdoc->LineStart(line); + LayoutLine(line, surface, vs, ll, pixelWidth); + for (int subLine = 1; subLine < ll->lines; subLine++) { + pdoc->InsertCString(posLineStart + (subLine - 1) * strlen(eol) + + ll->LineStart(subLine), eol); + targetEnd += static_cast(strlen(eol)); + } + } + lineEnd = pdoc->LineFromPosition(targetEnd); + } + } +} + +int Editor::SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) { + if (vs.markers[markerCheck].markType == SC_MARK_EMPTY) + return markerDefault; + return markerCheck; +} + +// Avoid 64 bit compiler warnings. +// Scintilla does not support text buffers larger than 2**31 +static int istrlen(const char *s) { + return static_cast(strlen(s)); +} + +bool ValidStyledText(ViewStyle &vs, size_t styleOffset, const StyledText &st) { + if (st.multipleStyles) { + for (size_t iStyle=0;iStyle(styles[endSegment+1]) == style)) + endSegment++; + width += surface->WidthText(vs.styles[style+styleOffset].font, text + start, endSegment - start + 1); + start = endSegment + 1; + } + return width; +} + +static int WidestLineWidth(Surface *surface, ViewStyle &vs, int styleOffset, const StyledText &st) { + int widthMax = 0; + size_t start = 0; + while (start < st.length) { + size_t lenLine = st.LineLength(start); + int widthSubLine; + if (st.multipleStyles) { + widthSubLine = WidthStyledText(surface, vs, styleOffset, st.text + start, st.styles + start, lenLine); + } else { + widthSubLine = surface->WidthText(vs.styles[styleOffset + st.style].font, st.text + start, lenLine); + } + if (widthSubLine > widthMax) + widthMax = widthSubLine; + start += lenLine + 1; + } + return widthMax; +} + +void DrawStyledText(Surface *surface, ViewStyle &vs, int styleOffset, PRectangle rcText, int ascent, + const StyledText &st, size_t start, size_t length) { + + if (st.multipleStyles) { + int x = rcText.left; + size_t i = 0; + while (i < length) { + size_t end = i; + int style = st.styles[i + start]; + while (end < length-1 && st.styles[start+end+1] == style) + end++; + style += styleOffset; + int width = surface->WidthText(vs.styles[style].font, st.text + start + i, end - i + 1); + PRectangle rcSegment = rcText; + rcSegment.left = x; + rcSegment.right = x + width + 1; + surface->DrawTextNoClip(rcSegment, vs.styles[style].font, + ascent, st.text + start + i, end - i + 1, + vs.styles[style].fore.allocated, + vs.styles[style].back.allocated); + x += width; + i = end + 1; + } + } else { + int style = st.style + styleOffset; + surface->DrawTextNoClip(rcText, vs.styles[style].font, + rcText.top + vs.maxAscent, st.text + start, length, + vs.styles[style].fore.allocated, + vs.styles[style].back.allocated); + } +} + +void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) { + if (vs.fixedColumnWidth == 0) + return; + + PRectangle rcMargin = GetClientRectangle(); + rcMargin.right = vs.fixedColumnWidth; + + if (!rc.Intersects(rcMargin)) + return; + + Surface *surface; + if (bufferedDraw) { + surface = pixmapSelMargin; + } else { + surface = surfWindow; + } + + PRectangle rcSelMargin = rcMargin; + rcSelMargin.right = rcMargin.left; + + for (int margin = 0; margin < vs.margins; margin++) { + if (vs.ms[margin].width > 0) { + + rcSelMargin.left = rcSelMargin.right; + rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width; + + if (vs.ms[margin].style != SC_MARGIN_NUMBER) { + /* alternate scheme: + if (vs.ms[margin].mask & SC_MASK_FOLDERS) + surface->FillRectangle(rcSelMargin, vs.styles[STYLE_DEFAULT].back.allocated); + else + // Required because of special way brush is created for selection margin + surface->FillRectangle(rcSelMargin, pixmapSelPattern); + */ + if (vs.ms[margin].mask & SC_MASK_FOLDERS) + // Required because of special way brush is created for selection margin + surface->FillRectangle(rcSelMargin, *pixmapSelPattern); + else { + ColourAllocated colour; + switch (vs.ms[margin].style) { + case SC_MARGIN_BACK: + colour = vs.styles[STYLE_DEFAULT].back.allocated; + break; + case SC_MARGIN_FORE: + colour = vs.styles[STYLE_DEFAULT].fore.allocated; + break; + default: + colour = vs.styles[STYLE_LINENUMBER].back.allocated; + break; + } + surface->FillRectangle(rcSelMargin, colour); + } + } else { + surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back.allocated); + } + + int visibleLine = topLine; + int yposScreen = 0; + + // Work out whether the top line is whitespace located after a + // lessening of fold level which implies a 'fold tail' but which should not + // be displayed until the last of a sequence of whitespace. + bool needWhiteClosure = false; + int level = pdoc->GetLevel(cs.DocFromDisplay(topLine)); + if (level & SC_FOLDLEVELWHITEFLAG) { + int lineBack = cs.DocFromDisplay(topLine); + int levelPrev = level; + while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) { + lineBack--; + levelPrev = pdoc->GetLevel(lineBack); + } + if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) { + if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK)) + needWhiteClosure = true; + } + } + + // Old code does not know about new markers needed to distinguish all cases + int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID, + SC_MARKNUM_FOLDEROPEN); + int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND, + SC_MARKNUM_FOLDER); + + while ((visibleLine < cs.LinesDisplayed()) && yposScreen < rcMargin.bottom) { + + PLATFORM_ASSERT(visibleLine < cs.LinesDisplayed()); + + int lineDoc = cs.DocFromDisplay(visibleLine); + PLATFORM_ASSERT(cs.GetVisible(lineDoc)); + bool firstSubLine = visibleLine == cs.DisplayFromDoc(lineDoc); + + // Decide which fold indicator should be displayed + level = pdoc->GetLevel(lineDoc); + int levelNext = pdoc->GetLevel(lineDoc + 1); + int marks = pdoc->GetMark(lineDoc); + if (!firstSubLine) + marks = 0; + int levelNum = level & SC_FOLDLEVELNUMBERMASK; + int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK; + if (level & SC_FOLDLEVELHEADERFLAG) { + if (firstSubLine) { + if (cs.GetExpanded(lineDoc)) { + if (levelNum == SC_FOLDLEVELBASE) + marks |= 1 << SC_MARKNUM_FOLDEROPEN; + else + marks |= 1 << folderOpenMid; + } else { + if (levelNum == SC_FOLDLEVELBASE) + marks |= 1 << SC_MARKNUM_FOLDER; + else + marks |= 1 << folderEnd; + } + } else { + marks |= 1 << SC_MARKNUM_FOLDERSUB; + } + needWhiteClosure = false; + } else if (level & SC_FOLDLEVELWHITEFLAG) { + if (needWhiteClosure) { + if (levelNext & SC_FOLDLEVELWHITEFLAG) { + marks |= 1 << SC_MARKNUM_FOLDERSUB; + } else if (levelNum > SC_FOLDLEVELBASE) { + marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL; + needWhiteClosure = false; + } else { + marks |= 1 << SC_MARKNUM_FOLDERTAIL; + needWhiteClosure = false; + } + } else if (levelNum > SC_FOLDLEVELBASE) { + if (levelNextNum < levelNum) { + if (levelNextNum > SC_FOLDLEVELBASE) { + marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL; + } else { + marks |= 1 << SC_MARKNUM_FOLDERTAIL; + } + } else { + marks |= 1 << SC_MARKNUM_FOLDERSUB; + } + } + } else if (levelNum > SC_FOLDLEVELBASE) { + if (levelNextNum < levelNum) { + needWhiteClosure = false; + if (levelNext & SC_FOLDLEVELWHITEFLAG) { + marks |= 1 << SC_MARKNUM_FOLDERSUB; + needWhiteClosure = true; + } else if (levelNextNum > SC_FOLDLEVELBASE) { + marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL; + } else { + marks |= 1 << SC_MARKNUM_FOLDERTAIL; + } + } else { + marks |= 1 << SC_MARKNUM_FOLDERSUB; + } + } + + marks &= vs.ms[margin].mask; + PRectangle rcMarker = rcSelMargin; + rcMarker.top = yposScreen; + rcMarker.bottom = yposScreen + vs.lineHeight; + if (vs.ms[margin].style == SC_MARGIN_NUMBER) { + char number[100]; + number[0] = '\0'; + if (firstSubLine) + sprintf(number, "%d", lineDoc + 1); + if (foldFlags & SC_FOLDFLAG_LEVELNUMBERS) { + int lev = pdoc->GetLevel(lineDoc); + sprintf(number, "%c%c %03X %03X", + (lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_', + (lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_', + lev & SC_FOLDLEVELNUMBERMASK, + lev >> 16 + ); + } + PRectangle rcNumber = rcMarker; + // Right justify + int width = surface->WidthText(vs.styles[STYLE_LINENUMBER].font, number, istrlen(number)); + int xpos = rcNumber.right - width - 3; + rcNumber.left = xpos; + surface->DrawTextNoClip(rcNumber, vs.styles[STYLE_LINENUMBER].font, + rcNumber.top + vs.maxAscent, number, istrlen(number), + vs.styles[STYLE_LINENUMBER].fore.allocated, + vs.styles[STYLE_LINENUMBER].back.allocated); + } else if (vs.ms[margin].style == SC_MARGIN_TEXT || vs.ms[margin].style == SC_MARGIN_RTEXT) { + if (firstSubLine) { + const StyledText stMargin = pdoc->MarginStyledText(lineDoc); + if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) { + surface->FillRectangle(rcMarker, + vs.styles[stMargin.StyleAt(0)+vs.marginStyleOffset].back.allocated); + if (vs.ms[margin].style == SC_MARGIN_RTEXT) { + int width = WidestLineWidth(surface, vs, vs.marginStyleOffset, stMargin); + rcMarker.left = rcMarker.right - width - 3; + } + DrawStyledText(surface, vs, vs.marginStyleOffset, rcMarker, rcMarker.top + vs.maxAscent, + stMargin, 0, stMargin.length); + } + } + } + + if (marks) { + for (int markBit = 0; (markBit < 32) && marks; markBit++) { + if (marks & 1) { + // ERAN IFRAH + int lev = (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELNUMBERMASK) - SC_FOLDLEVELBASE; + vs.markers[markBit].Draw(surface, rcMarker, vs.styles[STYLE_LINENUMBER].font, lev); + } + marks >>= 1; + } + } + + visibleLine++; + yposScreen += vs.lineHeight; + } + } + } + + PRectangle rcBlankMargin = rcMargin; + rcBlankMargin.left = rcSelMargin.right; + surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back.allocated); + + if (bufferedDraw) { + surfWindow->Copy(rcMargin, Point(), *pixmapSelMargin); + } +} + +void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid) { + int ydiff = (rcTab.bottom - rcTab.top) / 2; + int xhead = rcTab.right - 1 - ydiff; + if (xhead <= rcTab.left) { + ydiff -= rcTab.left - xhead - 1; + xhead = rcTab.left - 1; + } + if ((rcTab.left + 2) < (rcTab.right - 1)) + surface->MoveTo(rcTab.left + 2, ymid); + else + surface->MoveTo(rcTab.right - 1, ymid); + surface->LineTo(rcTab.right - 1, ymid); + surface->LineTo(xhead, ymid - ydiff); + surface->MoveTo(rcTab.right - 1, ymid); + surface->LineTo(xhead, ymid + ydiff); +} + +LineLayout *Editor::RetrieveLineLayout(int lineNumber) { + int posLineStart = pdoc->LineStart(lineNumber); + int posLineEnd = pdoc->LineStart(lineNumber + 1); + PLATFORM_ASSERT(posLineEnd >= posLineStart); + int lineCaret = pdoc->LineFromPosition(sel.MainCaret()); + return llc.Retrieve(lineNumber, lineCaret, + posLineEnd - posLineStart, pdoc->GetStyleClock(), + LinesOnScreen() + 1, pdoc->LinesTotal()); +} + +static bool GoodTrailByte(int v) { + return (v >= 0x80) && (v < 0xc0); +} + +bool BadUTF(const char *s, int len, int &trailBytes) { + // For the rules: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + if (trailBytes) { + trailBytes--; + return false; + } + const unsigned char *us = reinterpret_cast(s); + if (*us < 0x80) { + // Single bytes easy + return false; + } else if (*us > 0xF4) { + // Characters longer than 4 bytes not possible in current UTF-8 + return true; + } else if (*us >= 0xF0) { + // 4 bytes + if (len < 4) + return true; + if (GoodTrailByte(us[1]) && GoodTrailByte(us[2]) && GoodTrailByte(us[3])) { + if (*us == 0xf4) { + // Check if encoding a value beyond the last Unicode character 10FFFF + if (us[1] > 0x8f) { + return true; + } else if (us[1] == 0x8f) { + if (us[2] > 0xbf) { + return true; + } else if (us[2] == 0xbf) { + if (us[3] > 0xbf) { + return true; + } + } + } + } else if ((*us == 0xf0) && ((us[1] & 0xf0) == 0x80)) { + // Overlong + return true; + } + trailBytes = 3; + return false; + } else { + return true; + } + } else if (*us >= 0xE0) { + // 3 bytes + if (len < 3) + return true; + if (GoodTrailByte(us[1]) && GoodTrailByte(us[2])) { + if ((*us == 0xe0) && ((us[1] & 0xe0) == 0x80)) { + // Overlong + return true; + } + if ((*us == 0xed) && ((us[1] & 0xe0) == 0xa0)) { + // Surrogate + return true; + } + if ((*us == 0xef) && (us[1] == 0xbf) && (us[2] == 0xbe)) { + // U+FFFE + return true; + } + if ((*us == 0xef) && (us[1] == 0xbf) && (us[2] == 0xbf)) { + // U+FFFF + return true; + } + trailBytes = 2; + return false; + } else { + return true; + } + } else if (*us >= 0xC2) { + // 2 bytes + if (len < 2) + return true; + if (GoodTrailByte(us[1])) { + trailBytes = 1; + return false; + } else { + return true; + } + } else if (*us >= 0xC0) { + // Overlong encoding + return true; + } else { + // Trail byte + return true; + } +} + +/** + * Fill in the LineLayout data for the given line. + * Copy the given @a line and its styles from the document into local arrays. + * Also determine the x position at which each character starts. + */ +void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll, int width) { + if (!ll) + return; + + PLATFORM_ASSERT(line < pdoc->LinesTotal()); + PLATFORM_ASSERT(ll->chars != NULL); + int posLineStart = pdoc->LineStart(line); + int posLineEnd = pdoc->LineStart(line + 1); + // If the line is very long, limit the treatment to a length that should fit in the viewport + if (posLineEnd > (posLineStart + ll->maxLineLength)) { + posLineEnd = posLineStart + ll->maxLineLength; + } + if (ll->validity == LineLayout::llCheckTextAndStyle) { + int lineLength = posLineEnd - posLineStart; + if (!vstyle.viewEOL) { + int cid = posLineEnd - 1; + while ((cid > posLineStart) && IsEOLChar(pdoc->CharAt(cid))) { + cid--; + lineLength--; + } + } + if (lineLength == ll->numCharsInLine) { + // See if chars, styles, indicators, are all the same + bool allSame = true; + const int styleMask = pdoc->stylingBitsMask; + // Check base line layout + char styleByte = 0; + int numCharsInLine = 0; + while (numCharsInLine < lineLength) { + int charInDoc = numCharsInLine + posLineStart; + char chDoc = pdoc->CharAt(charInDoc); + styleByte = pdoc->StyleAt(charInDoc); + allSame = allSame && + (ll->styles[numCharsInLine] == static_cast(styleByte & styleMask)); + allSame = allSame && + (ll->indicators[numCharsInLine] == static_cast(styleByte & ~styleMask)); + if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseMixed) + allSame = allSame && + (ll->chars[numCharsInLine] == chDoc); + else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower) + allSame = allSame && + (ll->chars[numCharsInLine] == static_cast(tolower(chDoc))); + else // Style::caseUpper + allSame = allSame && + (ll->chars[numCharsInLine] == static_cast(toupper(chDoc))); + numCharsInLine++; + } + allSame = allSame && (ll->styles[numCharsInLine] == styleByte); // For eolFilled + if (allSame) { + ll->validity = LineLayout::llPositions; + } else { + ll->validity = LineLayout::llInvalid; + } + } else { + ll->validity = LineLayout::llInvalid; + } + } + if (ll->validity == LineLayout::llInvalid) { + ll->widthLine = LineLayout::wrapWidthInfinite; + ll->lines = 1; + int numCharsInLine = 0; + int numCharsBeforeEOL = 0; + if (vstyle.edgeState == EDGE_BACKGROUND) { + ll->edgeColumn = pdoc->FindColumn(line, theEdge); + if (ll->edgeColumn >= posLineStart) { + ll->edgeColumn -= posLineStart; + } + } else { + ll->edgeColumn = -1; + } + + char styleByte = 0; + int styleMask = pdoc->stylingBitsMask; + ll->styleBitsSet = 0; + // Fill base line layout + for (int charInDoc = posLineStart; charInDoc < posLineEnd; charInDoc++) { + char chDoc = pdoc->CharAt(charInDoc); + styleByte = pdoc->StyleAt(charInDoc); + ll->styleBitsSet |= styleByte; + if (vstyle.viewEOL || (!IsEOLChar(chDoc))) { + ll->chars[numCharsInLine] = chDoc; + ll->styles[numCharsInLine] = static_cast(styleByte & styleMask); + ll->indicators[numCharsInLine] = static_cast(styleByte & ~styleMask); + if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseUpper) + ll->chars[numCharsInLine] = static_cast(toupper(chDoc)); + else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower) + ll->chars[numCharsInLine] = static_cast(tolower(chDoc)); + numCharsInLine++; + if (!IsEOLChar(chDoc)) + numCharsBeforeEOL++; + } + } + ll->xHighlightGuide = 0; + // Extra element at the end of the line to hold end x position and act as + ll->chars[numCharsInLine] = 0; // Also triggers processing in the loops as this is a control character + ll->styles[numCharsInLine] = styleByte; // For eolFilled + ll->indicators[numCharsInLine] = 0; + + // Layout the line, determining the position of each character, + // with an extra element at the end for the end of the line. + int startseg = 0; // Start of the current segment, in char. number + int startsegx = 0; // Start of the current segment, in pixels + ll->positions[0] = 0; + unsigned int tabWidth = vstyle.spaceWidth * pdoc->tabInChars; + bool lastSegItalics = false; + Font &ctrlCharsFont = vstyle.styles[STYLE_CONTROLCHAR].font; + + int ctrlCharWidth[32] = {0}; + bool isControlNext = IsControlCharacter(ll->chars[0]); + int trailBytes = 0; + bool isBadUTFNext = IsUnicodeMode() && BadUTF(ll->chars, numCharsInLine, trailBytes); + for (int charInLine = 0; charInLine < numCharsInLine; charInLine++) { + bool isControl = isControlNext; + isControlNext = IsControlCharacter(ll->chars[charInLine + 1]); + bool isBadUTF = isBadUTFNext; + isBadUTFNext = IsUnicodeMode() && BadUTF(ll->chars + charInLine + 1, numCharsInLine - charInLine - 1, trailBytes); + if ((ll->styles[charInLine] != ll->styles[charInLine + 1]) || + isControl || isControlNext || isBadUTF || isBadUTFNext) { + ll->positions[startseg] = 0; + if (vstyle.styles[ll->styles[charInLine]].visible) { + if (isControl) { + if (ll->chars[charInLine] == '\t') { + ll->positions[charInLine + 1] = ((((startsegx + 2) / + tabWidth) + 1) * tabWidth) - startsegx; + } else if (controlCharSymbol < 32) { + if (ctrlCharWidth[ll->chars[charInLine]] == 0) { + const char *ctrlChar = ControlCharacterString(ll->chars[charInLine]); + // +3 For a blank on front and rounded edge each side: + ctrlCharWidth[ll->chars[charInLine]] = + surface->WidthText(ctrlCharsFont, ctrlChar, istrlen(ctrlChar)) + 3; + } + ll->positions[charInLine + 1] = ctrlCharWidth[ll->chars[charInLine]]; + } else { + char cc[2] = { static_cast(controlCharSymbol), '\0' }; + surface->MeasureWidths(ctrlCharsFont, cc, 1, + ll->positions + startseg + 1); + } + lastSegItalics = false; + } else if (isBadUTF) { + char hexits[4]; + sprintf(hexits, "x%2X", ll->chars[charInLine] & 0xff); + ll->positions[charInLine + 1] = + surface->WidthText(ctrlCharsFont, hexits, istrlen(hexits)) + 3; + } else { // Regular character + int lenSeg = charInLine - startseg + 1; + if ((lenSeg == 1) && (' ' == ll->chars[startseg])) { + lastSegItalics = false; + // Over half the segments are single characters and of these about half are space characters. + ll->positions[charInLine + 1] = vstyle.styles[ll->styles[charInLine]].spaceWidth; + } else { + lastSegItalics = vstyle.styles[ll->styles[charInLine]].italic; + posCache.MeasureWidths(surface, vstyle, ll->styles[charInLine], ll->chars + startseg, + lenSeg, ll->positions + startseg + 1); + } + } + } else { // invisible + for (int posToZero = startseg; posToZero <= (charInLine + 1); posToZero++) { + ll->positions[posToZero] = 0; + } + } + for (int posToIncrease = startseg; posToIncrease <= (charInLine + 1); posToIncrease++) { + ll->positions[posToIncrease] += startsegx; + } + startsegx = ll->positions[charInLine + 1]; + startseg = charInLine + 1; + } + } + // Small hack to make lines that end with italics not cut off the edge of the last character + if ((startseg > 0) && lastSegItalics) { + ll->positions[startseg] += 2; + } + ll->numCharsInLine = numCharsInLine; + ll->numCharsBeforeEOL = numCharsBeforeEOL; + ll->validity = LineLayout::llPositions; + } + // Hard to cope when too narrow, so just assume there is space + if (width < 20) { + width = 20; + } + if ((ll->validity == LineLayout::llPositions) || (ll->widthLine != width)) { + ll->widthLine = width; + if (width == LineLayout::wrapWidthInfinite) { + ll->lines = 1; + } else if (width > ll->positions[ll->numCharsInLine]) { + // Simple common case where line does not need wrapping. + ll->lines = 1; + } else { + if (wrapVisualFlags & SC_WRAPVISUALFLAG_END) { + width -= vstyle.aveCharWidth; // take into account the space for end wrap mark + } + ll->wrapIndent = wrapAddIndent; + if (wrapIndentMode != SC_WRAPINDENT_FIXED) + for (int i = 0; i < ll->numCharsInLine; i++) { + if (!IsSpaceOrTab(ll->chars[i])) { + ll->wrapIndent += ll->positions[i]; // Add line indent + break; + } + } + // Check for text width minimum + if (ll->wrapIndent > width - static_cast(vstyle.aveCharWidth) * 15) + ll->wrapIndent = wrapAddIndent; + // Check for wrapIndent minimum + if ((wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (ll->wrapIndent < static_cast(vstyle.aveCharWidth))) + ll->wrapIndent = vstyle.aveCharWidth; // Indent to show start visual + ll->lines = 0; + // Calculate line start positions based upon width. + int lastGoodBreak = 0; + int lastLineStart = 0; + int startOffset = 0; + int p = 0; + while (p < ll->numCharsInLine) { + if ((ll->positions[p + 1] - startOffset) >= width) { + if (lastGoodBreak == lastLineStart) { + // Try moving to start of last character + if (p > 0) { + lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1) + - posLineStart; + } + if (lastGoodBreak == lastLineStart) { + // Ensure at least one character on line. + lastGoodBreak = pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart + 1, 1) + - posLineStart; + } + } + lastLineStart = lastGoodBreak; + ll->lines++; + ll->SetLineStart(ll->lines, lastGoodBreak); + startOffset = ll->positions[lastGoodBreak]; + // take into account the space for start wrap mark and indent + startOffset -= ll->wrapIndent; + p = lastGoodBreak + 1; + continue; + } + if (p > 0) { + if (wrapState == eWrapChar) { + lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1) + - posLineStart; + p = pdoc->MovePositionOutsideChar(p + 1 + posLineStart, 1) - posLineStart; + continue; + } else if (ll->styles[p] != ll->styles[p - 1]) { + lastGoodBreak = p; + } else if (IsSpaceOrTab(ll->chars[p - 1]) && !IsSpaceOrTab(ll->chars[p])) { + lastGoodBreak = p; + } + } + p++; + } + ll->lines++; + } + ll->validity = LineLayout::llLines; + } +} + +ColourAllocated Editor::SelectionBackground(ViewStyle &vsDraw, bool main) { + return main ? + (primarySelection ? vsDraw.selbackground.allocated : vsDraw.selbackground2.allocated) : + vsDraw.selAdditionalBackground.allocated; +} + +ColourAllocated Editor::TextBackground(ViewStyle &vsDraw, bool overrideBackground, + ColourAllocated background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) { + if (inSelection == 1) { + if (vsDraw.selbackset && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) { + return SelectionBackground(vsDraw, true); + } + } else if (inSelection == 2) { + if (vsDraw.selbackset && (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA)) { + return SelectionBackground(vsDraw, false); + } + } else { + if ((vsDraw.edgeState == EDGE_BACKGROUND) && + (i >= ll->edgeColumn) && + !IsEOLChar(ll->chars[i])) + return vsDraw.edgecolour.allocated; + if (inHotspot && vsDraw.hotspotBackgroundSet) + return vsDraw.hotspotBackground.allocated; + if (overrideBackground && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD)) + return background; + } + return vsDraw.styles[styleMain].back.allocated; +} + +void Editor::DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight) { + Point from(0, ((lineVisible & 1) && (lineHeight & 1)) ? 1 : 0); + PRectangle rcCopyArea(start + 1, rcSegment.top, start + 2, rcSegment.bottom); + surface->Copy(rcCopyArea, from, + highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide); +} + +void Editor::DrawWrapMarker(Surface *surface, PRectangle rcPlace, + bool isEndMarker, ColourAllocated wrapColour) { + surface->PenColour(wrapColour); + + enum { xa = 1 }; // gap before start + int w = rcPlace.right - rcPlace.left - xa - 1; + + bool xStraight = isEndMarker; // x-mirrored symbol for start marker + bool yStraight = true; + //bool yStraight= isEndMarker; // comment in for start marker y-mirrowed + + int x0 = xStraight ? rcPlace.left : rcPlace.right - 1; + int y0 = yStraight ? rcPlace.top : rcPlace.bottom - 1; + + int dy = (rcPlace.bottom - rcPlace.top) / 5; + int y = (rcPlace.bottom - rcPlace.top) / 2 + dy; + + struct Relative { + Surface *surface; + int xBase; + int xDir; + int yBase; + int yDir; + void MoveTo(int xRelative, int yRelative) { + surface->MoveTo(xBase + xDir * xRelative, yBase + yDir * yRelative); + } + void LineTo(int xRelative, int yRelative) { + surface->LineTo(xBase + xDir * xRelative, yBase + yDir * yRelative); + } + }; + Relative rel = {surface, x0, xStraight ? 1 : -1, y0, yStraight ? 1 : -1}; + + // arrow head + rel.MoveTo(xa, y); + rel.LineTo(xa + 2*w / 3, y - dy); + rel.MoveTo(xa, y); + rel.LineTo(xa + 2*w / 3, y + dy); + + // arrow body + rel.MoveTo(xa, y); + rel.LineTo(xa + w, y); + rel.LineTo(xa + w, y - 2 * dy); + rel.LineTo(xa - 1, // on windows lineto is exclusive endpoint, perhaps GTK not... + y - 2 * dy); +} + +static void SimpleAlphaRectangle(Surface *surface, PRectangle rc, ColourAllocated fill, int alpha) { + if (alpha != SC_ALPHA_NOALPHA) { + surface->AlphaRectangle(rc, 0, fill, alpha, fill, alpha, 0); + } +} + +void DrawTextBlob(Surface *surface, ViewStyle &vsDraw, PRectangle rcSegment, + const char *s, ColourAllocated textBack, ColourAllocated textFore, bool twoPhaseDraw) { + if (!twoPhaseDraw) { + surface->FillRectangle(rcSegment, textBack); + } + Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font; + int normalCharHeight = surface->Ascent(ctrlCharsFont) - + surface->InternalLeading(ctrlCharsFont); + PRectangle rcCChar = rcSegment; + rcCChar.left = rcCChar.left + 1; + rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight; + rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1; + PRectangle rcCentral = rcCChar; + rcCentral.top++; + rcCentral.bottom--; + surface->FillRectangle(rcCentral, textFore); + PRectangle rcChar = rcCChar; + rcChar.left++; + rcChar.right--; + surface->DrawTextClipped(rcChar, ctrlCharsFont, + rcSegment.top + vsDraw.maxAscent, s, istrlen(s), + textBack, textFore); +} + +void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll, + int line, int lineEnd, int xStart, int subLine, int subLineStart, + bool overrideBackground, ColourAllocated background, + bool drawWrapMarkEnd, ColourAllocated wrapColour) { + + const int posLineStart = pdoc->LineStart(line); + const int styleMask = pdoc->stylingBitsMask; + PRectangle rcSegment = rcLine; + + const bool lastSubLine = subLine == (ll->lines - 1); + int virtualSpace = 0; + if (lastSubLine) { + const int spaceWidth = static_cast(vsDraw.styles[ll->EndLineStyle()].spaceWidth); + virtualSpace = sel.VirtualSpaceFor(pdoc->LineEnd(line)) * spaceWidth; + } + + // Fill in a PRectangle representing the end of line characters + + int xEol = ll->positions[lineEnd] - subLineStart; + + // Fill the virtual space and show selections within it + if (virtualSpace) { + rcSegment.left = xEol + xStart; + rcSegment.right = xEol + xStart + virtualSpace; + surface->FillRectangle(rcSegment, overrideBackground ? background : vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated); + if (!hideSelection && ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA))) { + SelectionSegment virtualSpaceRange(SelectionPosition(pdoc->LineEnd(line)), SelectionPosition(pdoc->LineEnd(line), sel.VirtualSpaceFor(pdoc->LineEnd(line)))); + for (size_t r=0; r(vsDraw.styles[ll->EndLineStyle()].spaceWidth); + rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] - subLineStart + portion.start.VirtualSpace() * spaceWidth; + rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] - subLineStart + portion.end.VirtualSpace() * spaceWidth; + rcSegment.left = Platform::Maximum(rcSegment.left, rcLine.left); + rcSegment.right = Platform::Minimum(rcSegment.right, rcLine.right); + surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, r == sel.Main())); + } + } + } + } + } + + int posAfterLineEnd = pdoc->LineStart(line + 1); + int eolInSelection = (subLine == (ll->lines - 1)) ? sel.InSelectionForEOL(posAfterLineEnd) : 0; + int alpha = (eolInSelection == 1) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha; + + // Draw the [CR], [LF], or [CR][LF] blobs if visible line ends are on + int blobsWidth = 0; + if (lastSubLine) { + for (int eolPos=ll->numCharsBeforeEOL; eolPosnumCharsInLine; eolPos++) { + rcSegment.left = xStart + ll->positions[eolPos] - subLineStart + virtualSpace; + rcSegment.right = xStart + ll->positions[eolPos+1] - subLineStart + virtualSpace; + blobsWidth += rcSegment.Width(); + const char *ctrlChar = ControlCharacterString(ll->chars[eolPos]); + int inSelection = 0; + bool inHotspot = false; + int styleMain = ll->styles[eolPos]; + ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, eolPos, ll); + ColourAllocated textFore = vsDraw.styles[styleMain].fore.allocated; + if (!hideSelection && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1)) { + if (alpha == SC_ALPHA_NOALPHA) { + surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1)); + } else { + surface->FillRectangle(rcSegment, textBack); + SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1), alpha); + } + } else { + surface->FillRectangle(rcSegment, textBack); + } + DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, textBack, textFore, twoPhaseDraw); + } + } + + // Draw the eol-is-selected rectangle + rcSegment.left = xEol + xStart + virtualSpace + blobsWidth; + rcSegment.right = xEol + xStart + virtualSpace + blobsWidth + vsDraw.aveCharWidth; + + if (!hideSelection && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) { + surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1)); + } else { + if (overrideBackground) { + surface->FillRectangle(rcSegment, background); + } else if (line < pdoc->LinesTotal() - 1) { + surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated); + } else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) { + surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated); + } else { + surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back.allocated); + } + if (!hideSelection && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) { + SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1), alpha); + } + } + + // Fill the remainder of the line + rcSegment.left = xEol + xStart + virtualSpace + blobsWidth + vsDraw.aveCharWidth; + rcSegment.right = rcLine.right; + + if (!hideSelection && vsDraw.selEOLFilled && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) { + surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1)); + } else { + if (overrideBackground) { + surface->FillRectangle(rcSegment, background); + } else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) { + surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated); + } else { + surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back.allocated); + } + if (!hideSelection && vsDraw.selEOLFilled && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) { + SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1), alpha); + } + } + + if (drawWrapMarkEnd) { + PRectangle rcPlace = rcSegment; + + if (wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_END_BY_TEXT) { + rcPlace.left = xEol + xStart + virtualSpace; + rcPlace.right = rcPlace.left + vsDraw.aveCharWidth; + } else { + // draw left of the right text margin, to avoid clipping by the current clip rect + rcPlace.right = rcLine.right - vs.rightMarginWidth; + rcPlace.left = rcPlace.right - vsDraw.aveCharWidth; + } + DrawWrapMarker(surface, rcPlace, true, wrapColour); + } +} + +void Editor::DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under) { + // Draw decorators + const int posLineStart = pdoc->LineStart(line); + const int lineStart = ll->LineStart(subLine); + const int subLineStart = ll->positions[lineStart]; + const int posLineEnd = posLineStart + lineEnd; + + if (!under) { + // Draw indicators + // foreach indicator... + for (int indicnum = 0, mask = 1 << pdoc->stylingBits; mask < 0x100; indicnum++) { + if (!(mask & ll->styleBitsSet)) { + mask <<= 1; + continue; + } + int startPos = -1; + // foreach style pos in line... + for (int indicPos = lineStart; indicPos <= lineEnd; indicPos++) { + // look for starts... + if (startPos < 0) { + // NOT in indicator run, looking for START + if (indicPos < lineEnd && (ll->indicators[indicPos] & mask)) + startPos = indicPos; + } + // ... or ends + if (startPos >= 0) { + // IN indicator run, looking for END + if (indicPos >= lineEnd || !(ll->indicators[indicPos] & mask)) { + // AT end of indicator run, DRAW it! + PRectangle rcIndic( + ll->positions[startPos] + xStart - subLineStart, + rcLine.top + vsDraw.maxAscent, + ll->positions[indicPos] + xStart - subLineStart, + rcLine.top + vsDraw.maxAscent + 3); + vsDraw.indicators[indicnum].Draw(surface, rcIndic, rcLine); + // RESET control var + startPos = -1; + } + } + } + mask <<= 1; + } + } + + for (Decoration *deco = pdoc->decorations.root; deco; deco = deco->next) { + if (under == vsDraw.indicators[deco->indicator].under) { + int startPos = posLineStart + lineStart; + if (!deco->rs.ValueAt(startPos)) { + startPos = deco->rs.EndRun(startPos); + } + while ((startPos < posLineEnd) && (deco->rs.ValueAt(startPos))) { + int endPos = deco->rs.EndRun(startPos); + if (endPos > posLineEnd) + endPos = posLineEnd; + PRectangle rcIndic( + ll->positions[startPos - posLineStart] + xStart - subLineStart, + rcLine.top + vsDraw.maxAscent, + ll->positions[endPos - posLineStart] + xStart - subLineStart, + rcLine.top + vsDraw.maxAscent + 3); + vsDraw.indicators[deco->indicator].Draw(surface, rcIndic, rcLine); + startPos = deco->rs.EndRun(endPos); + } + } + } +} + +void Editor::DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine) { + int indent = pdoc->GetLineIndentation(line) * vsDraw.spaceWidth; + PRectangle rcSegment = rcLine; + int annotationLine = subLine - ll->lines; + const StyledText stAnnotation = pdoc->AnnotationStyledText(line); + if (stAnnotation.text && ValidStyledText(vsDraw, vsDraw.annotationStyleOffset, stAnnotation)) { + surface->FillRectangle(rcSegment, vsDraw.styles[0].back.allocated); + if (vs.annotationVisible == ANNOTATION_BOXED) { + // Only care about calculating width if need to draw box + int widthAnnotation = WidestLineWidth(surface, vsDraw, vsDraw.annotationStyleOffset, stAnnotation); + widthAnnotation += vsDraw.spaceWidth * 2; // Margins + rcSegment.left = xStart + indent; + rcSegment.right = rcSegment.left + widthAnnotation; + surface->PenColour(vsDraw.styles[vsDraw.annotationStyleOffset].fore.allocated); + } else { + rcSegment.left = xStart; + } + const int annotationLines = pdoc->AnnotationLines(line); + size_t start = 0; + size_t lengthAnnotation = stAnnotation.LineLength(start); + int lineInAnnotation = 0; + while ((lineInAnnotation < annotationLine) && (start < stAnnotation.length)) { + start += lengthAnnotation + 1; + lengthAnnotation = stAnnotation.LineLength(start); + lineInAnnotation++; + } + PRectangle rcText = rcSegment; + if (vs.annotationVisible == ANNOTATION_BOXED) { + surface->FillRectangle(rcText, + vsDraw.styles[stAnnotation.StyleAt(start) + vsDraw.annotationStyleOffset].back.allocated); + rcText.left += vsDraw.spaceWidth; + } + DrawStyledText(surface, vsDraw, vsDraw.annotationStyleOffset, rcText, rcText.top + vsDraw.maxAscent, + stAnnotation, start, lengthAnnotation); + if (vs.annotationVisible == ANNOTATION_BOXED) { + + // Set grey border colour + ColourDesired greyCol (128, 128, 128); + ColourDesired lightGreyCol(192, 192, 192); + + surface->PenColour(greyCol.AsLong()); + + surface->MoveTo(rcSegment.left, rcSegment.top); + surface->LineTo(rcSegment.left, rcSegment.bottom); + + surface->PenColour(lightGreyCol.AsLong()); + surface->MoveTo(rcSegment.right, rcSegment.top); + surface->LineTo(rcSegment.right, rcSegment.bottom); + + if (subLine == ll->lines){ + surface->PenColour(lightGreyCol.AsLong()); + surface->MoveTo(rcSegment.left, rcSegment.top); + surface->LineTo(rcSegment.right, rcSegment.top); + } + if (subLine == ll->lines+annotationLines-1) { + surface->PenColour(greyCol.AsLong()); + surface->MoveTo(rcSegment.left, rcSegment.bottom - 1); + surface->LineTo(rcSegment.right, rcSegment.bottom - 1); + } + } + } +} + +void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine) { + + PRectangle rcSegment = rcLine; + + // Using one font for all control characters so it can be controlled independently to ensure + // the box goes around the characters tightly. Seems to be no way to work out what height + // is taken by an individual character - internal leading gives varying results. + Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font; + + // See if something overrides the line background color: Either if caret is on the line + // and background color is set for that, or if a marker is defined that forces its background + // color onto the line, or if a marker is defined but has no selection margin in which to + // display itself (as long as it's not an SC_MARK_EMPTY marker). These are checked in order + // with the earlier taking precedence. When multiple markers cause background override, + // the color for the highest numbered one is used. + bool overrideBackground = false; + ColourAllocated background; + if (caret.active && vsDraw.showCaretLineBackground && (vsDraw.caretLineAlpha == SC_ALPHA_NOALPHA) && ll->containsCaret) { + overrideBackground = true; + background = vsDraw.caretLineBackground.allocated; + } + if (!overrideBackground) { + int marks = pdoc->GetMark(line); + for (int markBit = 0; (markBit < 32) && marks; markBit++) { + if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND) && + (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) { + background = vsDraw.markers[markBit].back.allocated; + overrideBackground = true; + } + marks >>= 1; + } + } + if (!overrideBackground) { + if (vsDraw.maskInLine) { + int marksMasked = pdoc->GetMark(line) & vsDraw.maskInLine; + if (marksMasked) { + for (int markBit = 0; (markBit < 32) && marksMasked; markBit++) { + if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY) && + (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) { + overrideBackground = true; + background = vsDraw.markers[markBit].back.allocated; + } + marksMasked >>= 1; + } + } + } + } + + bool drawWhitespaceBackground = (vsDraw.viewWhitespace != wsInvisible) && + (!overrideBackground) && (vsDraw.whitespaceBackgroundSet); + + bool inIndentation = subLine == 0; // Do not handle indentation except on first subline. + int indentWidth = pdoc->IndentSize() * vsDraw.spaceWidth; + + int posLineStart = pdoc->LineStart(line); + + int startseg = ll->LineStart(subLine); + int subLineStart = ll->positions[startseg]; + if (subLine >= ll->lines) { + DrawAnnotation(surface, vsDraw, line, xStart, rcLine, ll, subLine); + return; // No further drawing + } + int lineStart = 0; + int lineEnd = 0; + if (subLine < ll->lines) { + lineStart = ll->LineStart(subLine); + lineEnd = ll->LineStart(subLine + 1); + if (subLine == ll->lines - 1) { + lineEnd = ll->numCharsBeforeEOL; + } + } + + ColourAllocated wrapColour = vsDraw.styles[STYLE_DEFAULT].fore.allocated; + if (vsDraw.whitespaceForegroundSet) + wrapColour = vsDraw.whitespaceForeground.allocated; + + bool drawWrapMarkEnd = false; + + if (wrapVisualFlags & SC_WRAPVISUALFLAG_END) { + if (subLine + 1 < ll->lines) { + drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0; + } + } + + if (ll->wrapIndent != 0) { + + bool continuedWrapLine = false; + if (subLine < ll->lines) { + continuedWrapLine = ll->LineStart(subLine) != 0; + } + + if (continuedWrapLine) { + // draw continuation rect + PRectangle rcPlace = rcSegment; + + rcPlace.left = ll->positions[startseg] + xStart - subLineStart; + rcPlace.right = rcPlace.left + ll->wrapIndent; + + // default bgnd here.. + surface->FillRectangle(rcSegment, overrideBackground ? background : + vsDraw.styles[STYLE_DEFAULT].back.allocated); + + // main line style would be below but this would be inconsistent with end markers + // also would possibly not be the style at wrap point + //int styleMain = ll->styles[lineStart]; + //surface->FillRectangle(rcPlace, vsDraw.styles[styleMain].back.allocated); + + if (wrapVisualFlags & SC_WRAPVISUALFLAG_START) { + + if (wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_START_BY_TEXT) + rcPlace.left = rcPlace.right - vsDraw.aveCharWidth; + else + rcPlace.right = rcPlace.left + vsDraw.aveCharWidth; + + DrawWrapMarker(surface, rcPlace, false, wrapColour); + } + + xStart += ll->wrapIndent; + } + } + + bool selBackDrawn = vsDraw.selbackset && + ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA)); + + // Does not take margin into account but not significant + int xStartVisible = subLineStart - xStart; + + ll->psel = &sel; + + BreakFinder bfBack(ll, lineStart, lineEnd, posLineStart, IsUnicodeMode(), xStartVisible, selBackDrawn); + int next = bfBack.First(); + + // Background drawing loop + while (twoPhaseDraw && (next < lineEnd)) { + + startseg = next; + next = bfBack.Next(); + int i = next - 1; + int iDoc = i + posLineStart; + + rcSegment.left = ll->positions[startseg] + xStart - subLineStart; + rcSegment.right = ll->positions[i + 1] + xStart - subLineStart; + // Only try to draw if really visible - enhances performance by not calling environment to + // draw strings that are completely past the right side of the window. + if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) { + // Clip to line rectangle, since may have a huge position which will not work with some platforms + rcSegment.left = Platform::Maximum(rcSegment.left, rcLine.left); + rcSegment.right = Platform::Minimum(rcSegment.right, rcLine.right); + + int styleMain = ll->styles[i]; + const int inSelection = hideSelection ? 0 : sel.CharacterInSelection(iDoc); + bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd); + ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll); + if (ll->chars[i] == '\t') { + // Tab display + if (drawWhitespaceBackground && + (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) + textBack = vsDraw.whitespaceBackground.allocated; + surface->FillRectangle(rcSegment, textBack); + } else if (IsControlCharacter(ll->chars[i])) { + // Control character display + inIndentation = false; + surface->FillRectangle(rcSegment, textBack); + } else { + // Normal text display + surface->FillRectangle(rcSegment, textBack); + if (vsDraw.viewWhitespace != wsInvisible || + (inIndentation && vsDraw.viewIndentationGuides == ivReal)) { + for (int cpos = 0; cpos <= i - startseg; cpos++) { + if (ll->chars[cpos + startseg] == ' ') { + if (drawWhitespaceBackground && + (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) { + PRectangle rcSpace(ll->positions[cpos + startseg] + xStart - subLineStart, + rcSegment.top, + ll->positions[cpos + startseg + 1] + xStart - subLineStart, + rcSegment.bottom); + surface->FillRectangle(rcSpace, vsDraw.whitespaceBackground.allocated); + } + } else { + inIndentation = false; + } + } + } + } + } else if (rcSegment.left > rcLine.right) { + break; + } + } + + if (twoPhaseDraw) { + DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd, + xStart, subLine, subLineStart, overrideBackground, background, + drawWrapMarkEnd, wrapColour); + } + + DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, true); + + if (vsDraw.edgeState == EDGE_LINE) { + int edgeX = theEdge * vsDraw.spaceWidth; + rcSegment.left = edgeX + xStart; + rcSegment.right = rcSegment.left + 1; + surface->FillRectangle(rcSegment, vsDraw.edgecolour.allocated); + } + + // Draw underline mark as part of background if not transparent + int marks = pdoc->GetMark(line); + int markBit; + for (markBit = 0; (markBit < 32) && marks; markBit++) { + if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE) && + (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) { + PRectangle rcUnderline = rcLine; + rcUnderline.top = rcUnderline.bottom - 2; + surface->FillRectangle(rcUnderline, vsDraw.markers[markBit].back.allocated); + } + marks >>= 1; + } + + inIndentation = subLine == 0; // Do not handle indentation except on first subline. + // Foreground drawing loop + BreakFinder bfFore(ll, lineStart, lineEnd, posLineStart, IsUnicodeMode(), xStartVisible, + ((!twoPhaseDraw && selBackDrawn) || vsDraw.selforeset)); + next = bfFore.First(); + + while (next < lineEnd) { + + startseg = next; + next = bfFore.Next(); + int i = next - 1; + + int iDoc = i + posLineStart; + + rcSegment.left = ll->positions[startseg] + xStart - subLineStart; + rcSegment.right = ll->positions[i + 1] + xStart - subLineStart; + // Only try to draw if really visible - enhances performance by not calling environment to + // draw strings that are completely past the right side of the window. + if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) { + int styleMain = ll->styles[i]; + ColourAllocated textFore = vsDraw.styles[styleMain].fore.allocated; + Font &textFont = vsDraw.styles[styleMain].font; + //hotspot foreground + if (ll->hsStart != -1 && iDoc >= ll->hsStart && iDoc < hsEnd) { + if (vsDraw.hotspotForegroundSet) + textFore = vsDraw.hotspotForeground.allocated; + } + const int inSelection = hideSelection ? 0 : sel.CharacterInSelection(iDoc); + if (inSelection && (vsDraw.selforeset)) { + textFore = (inSelection == 1) ? vsDraw.selforeground.allocated : vsDraw.selAdditionalForeground.allocated; + } + bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd); + ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll); + if (ll->chars[i] == '\t') { + // Tab display + if (!twoPhaseDraw) { + if (drawWhitespaceBackground && + (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) + textBack = vsDraw.whitespaceBackground.allocated; + surface->FillRectangle(rcSegment, textBack); + } + if ((vsDraw.viewWhitespace != wsInvisible) || + (inIndentation && vsDraw.viewIndentationGuides != ivNone)) { + if (vsDraw.whitespaceForegroundSet) + textFore = vsDraw.whitespaceForeground.allocated; + surface->PenColour(textFore); + } + if (inIndentation && vsDraw.viewIndentationGuides == ivReal) { + for (int xIG = ll->positions[i] / indentWidth * indentWidth; xIG < ll->positions[i + 1]; xIG += indentWidth) { + if (xIG >= ll->positions[i] && xIG > 0) { + DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIG + xStart, rcSegment, + (ll->xHighlightGuide == xIG)); + } + } + } + if (vsDraw.viewWhitespace != wsInvisible) { + if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) { + PRectangle rcTab(rcSegment.left + 1, rcSegment.top + 4, + rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent); + DrawTabArrow(surface, rcTab, rcSegment.top + vsDraw.lineHeight / 2); + } + } + } else if (IsControlCharacter(ll->chars[i])) { + // Control character display + inIndentation = false; + if (controlCharSymbol < 32) { + // Draw the character + const char *ctrlChar = ControlCharacterString(ll->chars[i]); + DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, textBack, textFore, twoPhaseDraw); + } else { + char cc[2] = { static_cast(controlCharSymbol), '\0' }; + surface->DrawTextNoClip(rcSegment, ctrlCharsFont, + rcSegment.top + vsDraw.maxAscent, + cc, 1, textBack, textFore); + } + } else if ((i == startseg) && (static_cast(ll->chars[i]) >= 0x80) && IsUnicodeMode()) { + // A single byte >= 0x80 in UTF-8 is a bad byte and is displayed as its hex value + char hexits[4]; + sprintf(hexits, "x%2X", ll->chars[i] & 0xff); + DrawTextBlob(surface, vsDraw, rcSegment, hexits, textBack, textFore, twoPhaseDraw); + } else { + // Normal text display + if (vsDraw.styles[styleMain].visible) { + if (twoPhaseDraw) { + surface->DrawTextTransparent(rcSegment, textFont, + rcSegment.top + vsDraw.maxAscent, ll->chars + startseg, + i - startseg + 1, textFore); + } else { + surface->DrawTextNoClip(rcSegment, textFont, + rcSegment.top + vsDraw.maxAscent, ll->chars + startseg, + i - startseg + 1, textFore, textBack); + } + } + if (vsDraw.viewWhitespace != wsInvisible || + (inIndentation && vsDraw.viewIndentationGuides != ivNone)) { + for (int cpos = 0; cpos <= i - startseg; cpos++) { + if (ll->chars[cpos + startseg] == ' ') { + if (vsDraw.viewWhitespace != wsInvisible) { + if (vsDraw.whitespaceForegroundSet) + textFore = vsDraw.whitespaceForeground.allocated; + if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) { + int xmid = (ll->positions[cpos + startseg] + ll->positions[cpos + startseg + 1]) / 2; + if (!twoPhaseDraw && drawWhitespaceBackground && + (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) { + textBack = vsDraw.whitespaceBackground.allocated; + PRectangle rcSpace(ll->positions[cpos + startseg] + xStart - subLineStart, + rcSegment.top, + ll->positions[cpos + startseg + 1] + xStart - subLineStart, + rcSegment.bottom); + surface->FillRectangle(rcSpace, textBack); + } + PRectangle rcDot(xmid + xStart - subLineStart, rcSegment.top + vsDraw.lineHeight / 2, 0, 0); + rcDot.right = rcDot.left + vs.whitespaceSize; + rcDot.bottom = rcDot.top + vs.whitespaceSize; + surface->FillRectangle(rcDot, textFore); + } + } + if (inIndentation && vsDraw.viewIndentationGuides == ivReal) { + int startSpace = ll->positions[cpos + startseg]; + if (startSpace > 0 && (startSpace % indentWidth == 0)) { + DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, startSpace + xStart, rcSegment, + (ll->xHighlightGuide == ll->positions[cpos + startseg])); + } + } + } else { + inIndentation = false; + } + } + } + } + if (ll->hsStart != -1 && vsDraw.hotspotUnderline && iDoc >= ll->hsStart && iDoc < ll->hsEnd ) { + PRectangle rcUL = rcSegment; + rcUL.top = rcUL.top + vsDraw.maxAscent + 1; + rcUL.bottom = rcUL.top + 1; + if (vsDraw.hotspotForegroundSet) + surface->FillRectangle(rcUL, vsDraw.hotspotForeground.allocated); + else + surface->FillRectangle(rcUL, textFore); + } else if (vsDraw.styles[styleMain].underline) { + PRectangle rcUL = rcSegment; + rcUL.top = rcUL.top + vsDraw.maxAscent + 1; + rcUL.bottom = rcUL.top + 1; + surface->FillRectangle(rcUL, textFore); + } + } else if (rcSegment.left > rcLine.right) { + break; + } + } + if ((vsDraw.viewIndentationGuides == ivLookForward || vsDraw.viewIndentationGuides == ivLookBoth) + && (subLine == 0)) { + int indentSpace = pdoc->GetLineIndentation(line); + int xStartText = ll->positions[pdoc->GetLineIndentPosition(line) - posLineStart]; + + // Find the most recent line with some text + + int lineLastWithText = line; + while (lineLastWithText > Platform::Maximum(line-20, 0) && pdoc->IsWhiteLine(lineLastWithText)) { + lineLastWithText--; + } + if (lineLastWithText < line) { + xStartText = 100000; // Don't limit to visible indentation on empty line + // This line is empty, so use indentation of last line with text + int indentLastWithText = pdoc->GetLineIndentation(lineLastWithText); + int isFoldHeader = pdoc->GetLevel(lineLastWithText) & SC_FOLDLEVELHEADERFLAG; + if (isFoldHeader) { + // Level is one more level than parent + indentLastWithText += pdoc->IndentSize(); + } + if (vsDraw.viewIndentationGuides == ivLookForward) { + // In viLookForward mode, previous line only used if it is a fold header + if (isFoldHeader) { + indentSpace = Platform::Maximum(indentSpace, indentLastWithText); + } + } else { // viLookBoth + indentSpace = Platform::Maximum(indentSpace, indentLastWithText); + } + } + + int lineNextWithText = line; + while (lineNextWithText < Platform::Minimum(line+20, pdoc->LinesTotal()) && pdoc->IsWhiteLine(lineNextWithText)) { + lineNextWithText++; + } + if (lineNextWithText > line) { + // This line is empty, so use indentation of last line with text + indentSpace = Platform::Maximum(indentSpace, + pdoc->GetLineIndentation(lineNextWithText)); + } + + for (int indentPos = pdoc->IndentSize(); indentPos < indentSpace; indentPos += pdoc->IndentSize()) { + int xIndent = indentPos * vsDraw.spaceWidth; + if (xIndent < xStartText) { + DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment, + (ll->xHighlightGuide == xIndent)); + } + } + } + + DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, false); + + // End of the drawing of the current line + if (!twoPhaseDraw) { + DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd, + xStart, subLine, subLineStart, overrideBackground, background, + drawWrapMarkEnd, wrapColour); + } + if (!hideSelection && ((vsDraw.selAlpha != SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha != SC_ALPHA_NOALPHA))) { + // For each selection draw + int virtualSpaces = 0; + if (subLine == (ll->lines - 1)) { + virtualSpaces = sel.VirtualSpaceFor(pdoc->LineEnd(line)); + } + SelectionPosition posStart(posLineStart); + SelectionPosition posEnd(posLineStart + lineEnd, virtualSpaces); + SelectionSegment virtualSpaceRange(posStart, posEnd); + for (size_t r=0; r(vsDraw.styles[ll->EndLineStyle()].spaceWidth); + rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] - subLineStart + portion.start.VirtualSpace() * spaceWidth; + rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] - subLineStart + portion.end.VirtualSpace() * spaceWidth; + rcSegment.left = Platform::Maximum(rcSegment.left, rcLine.left); + rcSegment.right = Platform::Minimum(rcSegment.right, rcLine.right); + SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, r == sel.Main()), alpha); + } + } + } + } + + // Draw any translucent whole line states + rcSegment.left = xStart; + rcSegment.right = rcLine.right - 1; + if (caret.active && vsDraw.showCaretLineBackground && ll->containsCaret) { + SimpleAlphaRectangle(surface, rcSegment, vsDraw.caretLineBackground.allocated, vsDraw.caretLineAlpha); + } + marks = pdoc->GetMark(line); + for (markBit = 0; (markBit < 32) && marks; markBit++) { + if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND)) { + SimpleAlphaRectangle(surface, rcSegment, vsDraw.markers[markBit].back.allocated, vsDraw.markers[markBit].alpha); + } else if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE)) { + PRectangle rcUnderline = rcSegment; + rcUnderline.top = rcUnderline.bottom - 2; + SimpleAlphaRectangle(surface, rcUnderline, vsDraw.markers[markBit].back.allocated, vsDraw.markers[markBit].alpha); + } + marks >>= 1; + } + if (vsDraw.maskInLine) { + int marksMasked = pdoc->GetMark(line) & vsDraw.maskInLine; + if (marksMasked) { + for (markBit = 0; (markBit < 32) && marksMasked; markBit++) { + if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY)) { + SimpleAlphaRectangle(surface, rcSegment, vsDraw.markers[markBit].back.allocated, vsDraw.markers[markBit].alpha); + } + marksMasked >>= 1; + } + } + } +} + +void Editor::DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine, + int xStart, int offset, int posCaret, PRectangle rcCaret, ColourAllocated caretColour) { + + int lineStart = ll->LineStart(subLine); + int posBefore = posCaret; + int posAfter = MovePositionOutsideChar(posCaret + 1, 1); + int numCharsToDraw = posAfter - posCaret; + + // Work out where the starting and ending offsets are. We need to + // see if the previous character shares horizontal space, such as a + // glyph / combining character. If so we'll need to draw that too. + int offsetFirstChar = offset; + int offsetLastChar = offset + (posAfter - posCaret); + while ((offsetLastChar - numCharsToDraw) >= lineStart) { + if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - numCharsToDraw]) > 0) { + // The char does not share horizontal space + break; + } + // Char shares horizontal space, update the numChars to draw + // Update posBefore to point to the prev char + posBefore = MovePositionOutsideChar(posBefore - 1, -1); + numCharsToDraw = posAfter - posBefore; + offsetFirstChar = offset - (posCaret - posBefore); + } + + // See if the next character shares horizontal space, if so we'll + // need to draw that too. + numCharsToDraw = offsetLastChar - offsetFirstChar; + while ((offsetLastChar < ll->LineStart(subLine + 1)) && (offsetLastChar <= ll->numCharsInLine)) { + // Update posAfter to point to the 2nd next char, this is where + // the next character ends, and 2nd next begins. We'll need + // to compare these two + posBefore = posAfter; + posAfter = MovePositionOutsideChar(posAfter + 1, 1); + offsetLastChar = offset + (posAfter - posCaret); + if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - (posAfter - posBefore)]) > 0) { + // The char does not share horizontal space + break; + } + // Char shares horizontal space, update the numChars to draw + numCharsToDraw = offsetLastChar - offsetFirstChar; + } + + // We now know what to draw, update the caret drawing rectangle + rcCaret.left = ll->positions[offsetFirstChar] - ll->positions[lineStart] + xStart; + rcCaret.right = ll->positions[offsetFirstChar+numCharsToDraw] - ll->positions[lineStart] + xStart; + + // Adjust caret position to take into account any word wrapping symbols. + if ((ll->wrapIndent != 0) && (lineStart != 0)) { + int wordWrapCharWidth = ll->wrapIndent; + rcCaret.left += wordWrapCharWidth; + rcCaret.right += wordWrapCharWidth; + } + + // This character is where the caret block is, we override the colours + // (inversed) for drawing the caret here. + int styleMain = ll->styles[offsetFirstChar]; + surface->DrawTextClipped(rcCaret, vsDraw.styles[styleMain].font, + rcCaret.top + vsDraw.maxAscent, ll->chars + offsetFirstChar, + numCharsToDraw, vsDraw.styles[styleMain].back.allocated, + caretColour); +} + +void Editor::RefreshPixMaps(Surface *surfaceWindow) { + if (!pixmapSelPattern->Initialised()) { + const int patternSize = 8; + pixmapSelPattern->InitPixMap(patternSize, patternSize, surfaceWindow, wMain.GetID()); + // This complex procedure is to reproduce the checkerboard dithered pattern used by windows + // for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half + // way between the chrome colour and the chrome highlight colour making a nice transition + // between the window chrome and the content area. And it works in low colour depths. + PRectangle rcPattern(0, 0, patternSize, patternSize); + + // Initialize default colours based on the chrome colour scheme. Typically the highlight is white. + ColourAllocated colourFMFill = vs.selbar.allocated; + ColourAllocated colourFMStripes = vs.selbarlight.allocated; + + if (!(vs.selbarlight.desired == ColourDesired(0xff, 0xff, 0xff))) { + // User has chosen an unusual chrome colour scheme so just use the highlight edge colour. + // (Typically, the highlight colour is white.) + colourFMFill = vs.selbarlight.allocated; + } + + if (vs.foldmarginColourSet) { + // override default fold margin colour + colourFMFill = vs.foldmarginColour.allocated; + } + if (vs.foldmarginHighlightColourSet) { + // override default fold margin highlight colour + colourFMStripes = vs.foldmarginHighlightColour.allocated; + } + + pixmapSelPattern->FillRectangle(rcPattern, colourFMFill); + pixmapSelPattern->PenColour(colourFMStripes); + for (int stripe = 0; stripe < patternSize; stripe++) { + // Alternating 1 pixel stripes is same as checkerboard. + pixmapSelPattern->MoveTo(0, stripe * 2); + pixmapSelPattern->LineTo(patternSize, stripe * 2 - patternSize); + } + } + + if (!pixmapIndentGuide->Initialised()) { + // 1 extra pixel in height so can handle odd/even positions and so produce a continuous line + pixmapIndentGuide->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID()); + pixmapIndentGuideHighlight->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID()); + PRectangle rcIG(0, 0, 1, vs.lineHeight); + pixmapIndentGuide->FillRectangle(rcIG, vs.styles[STYLE_INDENTGUIDE].back.allocated); + pixmapIndentGuide->PenColour(vs.styles[STYLE_INDENTGUIDE].fore.allocated); + pixmapIndentGuideHighlight->FillRectangle(rcIG, vs.styles[STYLE_BRACELIGHT].back.allocated); + pixmapIndentGuideHighlight->PenColour(vs.styles[STYLE_BRACELIGHT].fore.allocated); + for (int stripe = 1; stripe < vs.lineHeight + 1; stripe += 2) { + pixmapIndentGuide->MoveTo(0, stripe); + pixmapIndentGuide->LineTo(2, stripe); + pixmapIndentGuideHighlight->MoveTo(0, stripe); + pixmapIndentGuideHighlight->LineTo(2, stripe); + } + } + + if (bufferedDraw) { + if (!pixmapLine->Initialised()) { + PRectangle rcClient = GetClientRectangle(); + pixmapLine->InitPixMap(rcClient.Width(), vs.lineHeight, + surfaceWindow, wMain.GetID()); + pixmapSelMargin->InitPixMap(vs.fixedColumnWidth, + rcClient.Height(), surfaceWindow, wMain.GetID()); + } + } +} + +void Editor::DrawCarets(Surface *surface, ViewStyle &vsDraw, int lineDoc, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine) { + // When drag is active it is the only caret drawn + bool drawDrag = posDrag.IsValid(); + if (hideSelection && !drawDrag) + return; + const int posLineStart = pdoc->LineStart(lineDoc); + // For each selection draw + for (size_t r=0; (r(vsDraw.styles[ll->EndLineStyle()].spaceWidth); + const int virtualOffset = posCaret.VirtualSpace() * spaceWidth; + if (ll->InLine(offset, subLine) && offset <= ll->numCharsBeforeEOL) { + int xposCaret = ll->positions[offset] + virtualOffset - ll->positions[ll->LineStart(subLine)]; + if (ll->wrapIndent != 0) { + int lineStart = ll->LineStart(subLine); + if (lineStart != 0) // Wrapped + xposCaret += ll->wrapIndent; + } + bool caretBlinkState = (caret.active && caret.on) || (!additionalCaretsBlink && !mainCaret); + bool caretVisibleState = additionalCaretsVisible || mainCaret; + if ((xposCaret >= 0) && (vsDraw.caretWidth > 0) && (vsDraw.caretStyle != CARETSTYLE_INVISIBLE) && + ((posDrag.IsValid()) || (caretBlinkState && caretVisibleState))) { + bool caretAtEOF = false; + bool caretAtEOL = false; + bool drawBlockCaret = false; + int widthOverstrikeCaret; + int caretWidthOffset = 0; + PRectangle rcCaret = rcLine; + + if (posCaret.Position() == pdoc->Length()) { // At end of document + caretAtEOF = true; + widthOverstrikeCaret = vsDraw.aveCharWidth; + } else if ((posCaret.Position() - posLineStart) >= ll->numCharsInLine) { // At end of line + caretAtEOL = true; + widthOverstrikeCaret = vsDraw.aveCharWidth; + } else { + widthOverstrikeCaret = ll->positions[offset + 1] - ll->positions[offset]; + } + if (widthOverstrikeCaret < 3) // Make sure its visible + widthOverstrikeCaret = 3; + + if (xposCaret > 0) + caretWidthOffset = 1; // Move back so overlaps both character cells. + xposCaret += xStart; + if (posDrag.IsValid()) { + /* Dragging text, use a line caret */ + rcCaret.left = xposCaret - caretWidthOffset; + rcCaret.right = rcCaret.left + vsDraw.caretWidth; + } else if (inOverstrike) { + /* Overstrike (insert mode), use a modified bar caret */ + rcCaret.top = rcCaret.bottom - 2; + rcCaret.left = xposCaret + 1; + rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1; + } else if (vsDraw.caretStyle == CARETSTYLE_BLOCK) { + /* Block caret */ + rcCaret.left = xposCaret; + if (!caretAtEOL && !caretAtEOF && (ll->chars[offset] != '\t') && !(IsControlCharacter(ll->chars[offset]))) { + drawBlockCaret = true; + rcCaret.right = xposCaret + widthOverstrikeCaret; + } else { + rcCaret.right = xposCaret + vsDraw.aveCharWidth; + } + } else { + /* Line caret */ + rcCaret.left = xposCaret - caretWidthOffset; + rcCaret.right = rcCaret.left + vsDraw.caretWidth; + } + ColourAllocated caretColour = mainCaret ? vsDraw.caretcolour.allocated : vsDraw.additionalCaretColour.allocated; + if (drawBlockCaret) { + DrawBlockCaret(surface, vsDraw, ll, subLine, xStart, offset, posCaret.Position(), rcCaret, caretColour); + } else { + surface->FillRectangle(rcCaret, caretColour); + } + } + } + if (drawDrag) + break; + } +} + +void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) { + //Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n", + // paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom); + + StyleToPositionInView(PositionAfterArea(rcArea)); + + pixmapLine->Release(); + RefreshStyleData(); + RefreshPixMaps(surfaceWindow); + + PRectangle rcClient = GetClientRectangle(); + //Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d) %d\n", + // rcClient.left, rcClient.top, rcClient.right, rcClient.bottom); + + surfaceWindow->SetPalette(&palette, true); + pixmapLine->SetPalette(&palette, !hasFocus); + + int screenLinePaintFirst = rcArea.top / vs.lineHeight; + + int xStart = vs.fixedColumnWidth - xOffset; + int ypos = 0; + if (!bufferedDraw) + ypos += screenLinePaintFirst * vs.lineHeight; + int yposScreen = screenLinePaintFirst * vs.lineHeight; + + bool paintAbandonedByStyling = paintState == paintAbandoned; + if (needUpdateUI) { + // Deselect palette by selecting a temporary palette + Palette palTemp; + surfaceWindow->SetPalette(&palTemp, true); + + NotifyUpdateUI(); + needUpdateUI = false; + + RefreshStyleData(); + RefreshPixMaps(surfaceWindow); + surfaceWindow->SetPalette(&palette, true); + pixmapLine->SetPalette(&palette, !hasFocus); + } + + // Call priority lines wrap on a window of lines which are likely + // to rendered with the following paint (that is wrap the visible + // lines first). + int startLineToWrap = cs.DocFromDisplay(topLine) - 5; + if (startLineToWrap < 0) + startLineToWrap = 0; + if (WrapLines(false, startLineToWrap)) { + // The wrapping process has changed the height of some lines so + // abandon this paint for a complete repaint. + if (AbandonPaint()) { + return; + } + RefreshPixMaps(surfaceWindow); // In case pixmaps invalidated by scrollbar change + } + PLATFORM_ASSERT(pixmapSelPattern->Initialised()); + + if (paintState != paintAbandoned) { + PaintSelMargin(surfaceWindow, rcArea); + + PRectangle rcRightMargin = rcClient; + rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth; + if (rcArea.Intersects(rcRightMargin)) { + surfaceWindow->FillRectangle(rcRightMargin, vs.styles[STYLE_DEFAULT].back.allocated); + } + } + + if (paintState == paintAbandoned) { + // Either styling or NotifyUpdateUI noticed that painting is needed + // outside the current painting rectangle + //Platform::DebugPrintf("Abandoning paint\n"); + if (wrapState != eWrapNone) { + if (paintAbandonedByStyling) { + // Styling has spilled over a line end, such as occurs by starting a multiline + // comment. The width of subsequent text may have changed, so rewrap. + NeedWrapping(cs.DocFromDisplay(topLine)); + } + } + return; + } + //Platform::DebugPrintf("start display %d, offset = %d\n", pdoc->Length(), xOffset); + + // Do the painting + if (rcArea.right > vs.fixedColumnWidth) { + + Surface *surface = surfaceWindow; + if (bufferedDraw) { + surface = pixmapLine; + PLATFORM_ASSERT(pixmapLine->Initialised()); + } + surface->SetUnicodeMode(IsUnicodeMode()); + surface->SetDBCSMode(CodePage()); + + int visibleLine = topLine + screenLinePaintFirst; + + SelectionPosition posCaret = sel.RangeMain().caret; + if (posDrag.IsValid()) + posCaret = posDrag; + int lineCaret = pdoc->LineFromPosition(posCaret.Position()); + + // Remove selection margin from drawing area so text will not be drawn + // on it in unbuffered mode. + PRectangle rcTextArea = rcClient; + rcTextArea.left = vs.fixedColumnWidth; + rcTextArea.right -= vs.rightMarginWidth; + surfaceWindow->SetClip(rcTextArea); + + // Loop on visible lines + //double durLayout = 0.0; + //double durPaint = 0.0; + //double durCopy = 0.0; + //ElapsedTime etWhole; + int lineDocPrevious = -1; // Used to avoid laying out one document line multiple times + AutoLineLayout ll(llc, 0); + while (visibleLine < cs.LinesDisplayed() && yposScreen < rcArea.bottom) { + + int lineDoc = cs.DocFromDisplay(visibleLine); + // Only visible lines should be handled by the code within the loop + PLATFORM_ASSERT(cs.GetVisible(lineDoc)); + int lineStartSet = cs.DisplayFromDoc(lineDoc); + int subLine = visibleLine - lineStartSet; + + // Copy this line and its styles from the document into local arrays + // and determine the x position at which each character starts. + //ElapsedTime et; + if (lineDoc != lineDocPrevious) { + ll.Set(0); + ll.Set(RetrieveLineLayout(lineDoc)); + LayoutLine(lineDoc, surface, vs, ll, wrapWidth); + lineDocPrevious = lineDoc; + } + //durLayout += et.Duration(true); + + if (ll) { + ll->containsCaret = lineDoc == lineCaret; + if (hideSelection) { + ll->containsCaret = false; + } + + GetHotSpotRange(ll->hsStart, ll->hsEnd); + + PRectangle rcLine = rcClient; + rcLine.top = ypos; + rcLine.bottom = ypos + vs.lineHeight; + + Range rangeLine(pdoc->LineStart(lineDoc), pdoc->LineStart(lineDoc + 1)); + // Highlight the current braces if any + ll->SetBracesHighlight(rangeLine, braces, static_cast(bracesMatchStyle), + highlightGuideColumn * vs.spaceWidth); + + // Draw the line + DrawLine(surface, vs, lineDoc, visibleLine, xStart, rcLine, ll, subLine); + //durPaint += et.Duration(true); + + // Restore the previous styles for the brace highlights in case layout is in cache. + ll->RestoreBracesHighlight(rangeLine, braces); + + bool expanded = cs.GetExpanded(lineDoc); + // Paint the line above the fold + if ((expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED)) + || + (!expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_CONTRACTED))) { + if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) { + PRectangle rcFoldLine = rcLine; + rcFoldLine.bottom = rcFoldLine.top + 1; + surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated); + } + } + // Paint the line below the fold + if ((expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_EXPANDED)) + || + (!expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) { + if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) { + PRectangle rcFoldLine = rcLine; + rcFoldLine.top = rcFoldLine.bottom - 1; + surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated); + } + } + + DrawCarets(surface, vs, lineDoc, xStart, rcLine, ll, subLine); + + if (bufferedDraw) { + Point from(vs.fixedColumnWidth, 0); + PRectangle rcCopyArea(vs.fixedColumnWidth, yposScreen, + rcClient.right, yposScreen + vs.lineHeight); + surfaceWindow->Copy(rcCopyArea, from, *pixmapLine); + } + + lineWidthMaxSeen = Platform::Maximum( + lineWidthMaxSeen, ll->positions[ll->numCharsInLine]); + //durCopy += et.Duration(true); + } + + if (!bufferedDraw) { + ypos += vs.lineHeight; + } + + yposScreen += vs.lineHeight; + visibleLine++; + + //gdk_flush(); + } + ll.Set(0); + //if (durPaint < 0.00000001) + // durPaint = 0.00000001; + + // Right column limit indicator + PRectangle rcBeyondEOF = rcClient; + rcBeyondEOF.left = vs.fixedColumnWidth; + rcBeyondEOF.right = rcBeyondEOF.right; + rcBeyondEOF.top = (cs.LinesDisplayed() - topLine) * vs.lineHeight; + if (rcBeyondEOF.top < rcBeyondEOF.bottom) { + surfaceWindow->FillRectangle(rcBeyondEOF, vs.styles[STYLE_DEFAULT].back.allocated); + if (vs.edgeState == EDGE_LINE) { + int edgeX = theEdge * vs.spaceWidth; + rcBeyondEOF.left = edgeX + xStart; + rcBeyondEOF.right = rcBeyondEOF.left + 1; + surfaceWindow->FillRectangle(rcBeyondEOF, vs.edgecolour.allocated); + } + } + //Platform::DebugPrintf( + //"Layout:%9.6g Paint:%9.6g Ratio:%9.6g Copy:%9.6g Total:%9.6g\n", + //durLayout, durPaint, durLayout / durPaint, durCopy, etWhole.Duration()); + NotifyPainted(); + } +} + +// Space (3 space characters) between line numbers and text when printing. +#define lineNumberPrintSpace " " + +ColourDesired InvertedLight(ColourDesired orig) { + unsigned int r = orig.GetRed(); + unsigned int g = orig.GetGreen(); + unsigned int b = orig.GetBlue(); + unsigned int l = (r + g + b) / 3; // There is a better calculation for this that matches human eye + unsigned int il = 0xff - l; + if (l == 0) + return ColourDesired(0xff, 0xff, 0xff); + r = r * il / l; + g = g * il / l; + b = b * il / l; + return ColourDesired(Platform::Minimum(r, 0xff), Platform::Minimum(g, 0xff), Platform::Minimum(b, 0xff)); +} + +// This is mostly copied from the Paint method but with some things omitted +// such as the margin markers, line numbers, selection and caret +// Should be merged back into a combined Draw method. +long Editor::FormatRange(bool draw, Sci_RangeToFormat *pfr) { + if (!pfr) + return 0; + + AutoSurface surface(pfr->hdc, this); + if (!surface) + return 0; + AutoSurface surfaceMeasure(pfr->hdcTarget, this); + if (!surfaceMeasure) { + return 0; + } + + // Can't use measurements cached for screen + posCache.Clear(); + + ViewStyle vsPrint(vs); + + // Modify the view style for printing as do not normally want any of the transient features to be printed + // Printing supports only the line number margin. + int lineNumberIndex = -1; + for (int margin = 0; margin < ViewStyle::margins; margin++) { + if ((vsPrint.ms[margin].style == SC_MARGIN_NUMBER) && (vsPrint.ms[margin].width > 0)) { + lineNumberIndex = margin; + } else { + vsPrint.ms[margin].width = 0; + } + } + vsPrint.showMarkedLines = false; + vsPrint.fixedColumnWidth = 0; + vsPrint.zoomLevel = printMagnification; + vsPrint.viewIndentationGuides = ivNone; + // Don't show the selection when printing + vsPrint.selbackset = false; + vsPrint.selforeset = false; + vsPrint.selAlpha = SC_ALPHA_NOALPHA; + vsPrint.selAdditionalAlpha = SC_ALPHA_NOALPHA; + vsPrint.whitespaceBackgroundSet = false; + vsPrint.whitespaceForegroundSet = false; + vsPrint.showCaretLineBackground = false; + + // Set colours for printing according to users settings + for (size_t sty = 0;sty < vsPrint.stylesSize;sty++) { + if (printColourMode == SC_PRINT_INVERTLIGHT) { + vsPrint.styles[sty].fore.desired = InvertedLight(vsPrint.styles[sty].fore.desired); + vsPrint.styles[sty].back.desired = InvertedLight(vsPrint.styles[sty].back.desired); + } else if (printColourMode == SC_PRINT_BLACKONWHITE) { + vsPrint.styles[sty].fore.desired = ColourDesired(0, 0, 0); + vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff); + } else if (printColourMode == SC_PRINT_COLOURONWHITE) { + vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff); + } else if (printColourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) { + if (sty <= STYLE_DEFAULT) { + vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff); + } + } + } + // White background for the line numbers + vsPrint.styles[STYLE_LINENUMBER].back.desired = ColourDesired(0xff, 0xff, 0xff); + + vsPrint.Refresh(*surfaceMeasure); + // Determining width must hapen after fonts have been realised in Refresh + int lineNumberWidth = 0; + if (lineNumberIndex >= 0) { + lineNumberWidth = surfaceMeasure->WidthText(vsPrint.styles[STYLE_LINENUMBER].font, + "99999" lineNumberPrintSpace, 5 + istrlen(lineNumberPrintSpace)); + vsPrint.ms[lineNumberIndex].width = lineNumberWidth; + vsPrint.Refresh(*surfaceMeasure); // Recalculate fixedColumnWidth + } + // Ensure colours are set up + vsPrint.RefreshColourPalette(palette, true); + vsPrint.RefreshColourPalette(palette, false); + + int linePrintStart = pdoc->LineFromPosition(pfr->chrg.cpMin); + int linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1; + if (linePrintLast < linePrintStart) + linePrintLast = linePrintStart; + int linePrintMax = pdoc->LineFromPosition(pfr->chrg.cpMax); + if (linePrintLast > linePrintMax) + linePrintLast = linePrintMax; + //Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n", + // linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight, + // surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font)); + int endPosPrint = pdoc->Length(); + if (linePrintLast < pdoc->LinesTotal()) + endPosPrint = pdoc->LineStart(linePrintLast + 1); + + // Ensure we are styled to where we are formatting. + pdoc->EnsureStyledTo(endPosPrint); + + int xStart = vsPrint.fixedColumnWidth + pfr->rc.left; + int ypos = pfr->rc.top; + + int lineDoc = linePrintStart; + + int nPrintPos = pfr->chrg.cpMin; + int visibleLine = 0; + int widthPrint = pfr->rc.right - pfr->rc.left - vsPrint.fixedColumnWidth; + if (printWrapState == eWrapNone) + widthPrint = LineLayout::wrapWidthInfinite; + + while (lineDoc <= linePrintLast && ypos < pfr->rc.bottom) { + + // When printing, the hdc and hdcTarget may be the same, so + // changing the state of surfaceMeasure may change the underlying + // state of surface. Therefore, any cached state is discarded before + // using each surface. + surfaceMeasure->FlushCachedState(); + + // Copy this line and its styles from the document into local arrays + // and determine the x position at which each character starts. + LineLayout ll(8000); + LayoutLine(lineDoc, surfaceMeasure, vsPrint, &ll, widthPrint); + + ll.containsCaret = false; + + PRectangle rcLine; + rcLine.left = pfr->rc.left; + rcLine.top = ypos; + rcLine.right = pfr->rc.right - 1; + rcLine.bottom = ypos + vsPrint.lineHeight; + + // When document line is wrapped over multiple display lines, find where + // to start printing from to ensure a particular position is on the first + // line of the page. + if (visibleLine == 0) { + int startWithinLine = nPrintPos - pdoc->LineStart(lineDoc); + for (int iwl = 0; iwl < ll.lines - 1; iwl++) { + if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) { + visibleLine = -iwl; + } + } + + if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) { + visibleLine = -(ll.lines - 1); + } + } + + if (draw && lineNumberWidth && + (ypos + vsPrint.lineHeight <= pfr->rc.bottom) && + (visibleLine >= 0)) { + char number[100]; + sprintf(number, "%d" lineNumberPrintSpace, lineDoc + 1); + PRectangle rcNumber = rcLine; + rcNumber.right = rcNumber.left + lineNumberWidth; + // Right justify + rcNumber.left = rcNumber.right - surfaceMeasure->WidthText( + vsPrint.styles[STYLE_LINENUMBER].font, number, istrlen(number)); + surface->FlushCachedState(); + surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font, + ypos + vsPrint.maxAscent, number, istrlen(number), + vsPrint.styles[STYLE_LINENUMBER].fore.allocated, + vsPrint.styles[STYLE_LINENUMBER].back.allocated); + } + + // Draw the line + surface->FlushCachedState(); + + for (int iwl = 0; iwl < ll.lines; iwl++) { + if (ypos + vsPrint.lineHeight <= pfr->rc.bottom) { + if (visibleLine >= 0) { + if (draw) { + rcLine.top = ypos; + rcLine.bottom = ypos + vsPrint.lineHeight; + DrawLine(surface, vsPrint, lineDoc, visibleLine, xStart, rcLine, &ll, iwl); + } + ypos += vsPrint.lineHeight; + } + visibleLine++; + if (iwl == ll.lines - 1) + nPrintPos = pdoc->LineStart(lineDoc + 1); + else + nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl); + } + } + + ++lineDoc; + } + + // Clear cache so measurements are not used for screen + posCache.Clear(); + + return nPrintPos; +} + +int Editor::TextWidth(int style, const char *text) { + RefreshStyleData(); + AutoSurface surface(this); + if (surface) { + return surface->WidthText(vs.styles[style].font, text, istrlen(text)); + } else { + return 1; + } +} + +// Empty method is overridden on GTK+ to show / hide scrollbars +void Editor::ReconfigureScrollBars() {} + +void Editor::SetScrollBars() { + RefreshStyleData(); + + int nMax = MaxScrollPos(); + int nPage = LinesOnScreen(); + bool modified = ModifyScrollBars(nMax + nPage - 1, nPage); + if (modified) { + DwellEnd(true); + } + + // TODO: ensure always showing as many lines as possible + // May not be, if, for example, window made larger + if (topLine > MaxScrollPos()) { + SetTopLine(Platform::Clamp(topLine, 0, MaxScrollPos())); + SetVerticalScrollPos(); + Redraw(); + } + if (modified) { + if (!AbandonPaint()) + Redraw(); + } + //Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage); +} + +void Editor::ChangeSize() { + DropGraphics(); + SetScrollBars(); + if (wrapState != eWrapNone) { + PRectangle rcTextArea = GetClientRectangle(); + rcTextArea.left = vs.fixedColumnWidth; + rcTextArea.right -= vs.rightMarginWidth; + if (wrapWidth != rcTextArea.Width()) { + NeedWrapping(); + Redraw(); + } + } +} + +int Editor::InsertSpace(int position, unsigned int spaces) { + if (spaces > 0) { + std::string spaceText(spaces, ' '); + pdoc->InsertString(position, spaceText.c_str(), spaces); + position += spaces; + } + return position; +} + +void Editor::AddChar(char ch) { + char s[2]; + s[0] = ch; + s[1] = '\0'; + AddCharUTF(s, 1); +} + +void Editor::FilterSelections() { + if (!additionalSelectionTyping && (sel.Count() > 1)) { + SelectionRange rangeOnly = sel.RangeMain(); + InvalidateSelection(rangeOnly, true); + sel.SetSelection(rangeOnly); + } +} + +// AddCharUTF inserts an array of bytes which may or may not be in UTF-8. +void Editor::AddCharUTF(char *s, unsigned int len, bool treatAsDBCS) { + FilterSelections(); + { + UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike); + for (size_t r=0; rDeleteChars(positionInsert, sel.Range(r).Length()); + sel.Range(r).ClearVirtualSpace(); + } else { + // Range is all virtual so collapse to start of virtual space + sel.Range(r).MinimizeVirtualSpace(); + } + } else if (inOverstrike) { + if (positionInsert < pdoc->Length()) { + if (!IsEOLChar(pdoc->CharAt(positionInsert))) { + pdoc->DelChar(positionInsert); + sel.Range(r).ClearVirtualSpace(); + } + } + } + positionInsert = InsertSpace(positionInsert, sel.Range(r).caret.VirtualSpace()); + if (pdoc->InsertString(positionInsert, s, len)) { + sel.Range(r).caret.SetPosition(positionInsert + len); + sel.Range(r).anchor.SetPosition(positionInsert + len); + } + sel.Range(r).ClearVirtualSpace(); + // If in wrap mode rewrap current line so EnsureCaretVisible has accurate information + if (wrapState != eWrapNone) { + AutoSurface surface(this); + if (surface) { + if (WrapOneLine(surface, pdoc->LineFromPosition(positionInsert))) { + SetScrollBars(); + SetVerticalScrollPos(); + Redraw(); + } + } + } + } + } + } + if (wrapState != eWrapNone) { + SetScrollBars(); + } + ThinRectangularRange(); + // If in wrap mode rewrap current line so EnsureCaretVisible has accurate information + EnsureCaretVisible(); + // Avoid blinking during rapid typing: + ShowCaretAtCurrentPosition(); + if (!caretSticky) { + SetLastXChosen(); + } + + if (treatAsDBCS) { + NotifyChar((static_cast(s[0]) << 8) | + static_cast(s[1])); + } else { + int byte = static_cast(s[0]); + if ((byte < 0xC0) || (1 == len)) { + // Handles UTF-8 characters between 0x01 and 0x7F and single byte + // characters when not in UTF-8 mode. + // Also treats \0 and naked trail bytes 0x80 to 0xBF as valid + // characters representing themselves. + } else { + // Unroll 1 to 3 byte UTF-8 sequences. See reference data at: + // http://www.cl.cam.ac.uk/~mgk25/unicode.html + // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt + if (byte < 0xE0) { + int byte2 = static_cast(s[1]); + if ((byte2 & 0xC0) == 0x80) { + // Two-byte-character lead-byte followed by a trail-byte. + byte = (((byte & 0x1F) << 6) | (byte2 & 0x3F)); + } + // A two-byte-character lead-byte not followed by trail-byte + // represents itself. + } else if (byte < 0xF0) { + int byte2 = static_cast(s[1]); + int byte3 = static_cast(s[2]); + if (((byte2 & 0xC0) == 0x80) && ((byte3 & 0xC0) == 0x80)) { + // Three-byte-character lead byte followed by two trail bytes. + byte = (((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | + (byte3 & 0x3F)); + } + // A three-byte-character lead-byte not followed by two trail-bytes + // represents itself. + } + } + NotifyChar(byte); + } + + if (recordingMacro) { + NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast(s)); + } +} + +void Editor::InsertPaste(SelectionPosition selStart, const char *text, int len) { + if (multiPasteMode == SC_MULTIPASTE_ONCE) { + selStart = SelectionPosition(InsertSpace(selStart.Position(), selStart.VirtualSpace())); + if (pdoc->InsertString(selStart.Position(), text, len)) { + SetEmptySelection(selStart.Position() + len); + } + } else { + // SC_MULTIPASTE_EACH + for (size_t r=0; rDeleteChars(positionInsert, sel.Range(r).Length()); + sel.Range(r).ClearVirtualSpace(); + } else { + // Range is all virtual so collapse to start of virtual space + sel.Range(r).MinimizeVirtualSpace(); + } + } + positionInsert = InsertSpace(positionInsert, sel.Range(r).caret.VirtualSpace()); + if (pdoc->InsertString(positionInsert, text, len)) { + sel.Range(r).caret.SetPosition(positionInsert + len); + sel.Range(r).anchor.SetPosition(positionInsert + len); + } + sel.Range(r).ClearVirtualSpace(); + } + } + } +} + +void Editor::ClearSelection() { + if (!sel.IsRectangular()) + FilterSelections(); + UndoGroup ug(pdoc); + for (size_t r=0; rDeleteChars(sel.Range(r).Start().Position(), + sel.Range(r).Length()); + sel.Range(r) = sel.Range(r).Start(); + } + } + } + ThinRectangularRange(); + sel.RemoveDuplicates(); + ClaimSelection(); +} + +void Editor::ClearAll() { + { + UndoGroup ug(pdoc); + if (0 != pdoc->Length()) { + pdoc->DeleteChars(0, pdoc->Length()); + } + if (!pdoc->IsReadOnly()) { + cs.Clear(); + pdoc->AnnotationClearAll(); + pdoc->MarginClearAll(); + } + } + sel.Clear(); + SetTopLine(0); + SetVerticalScrollPos(); + InvalidateStyleRedraw(); +} + +void Editor::ClearDocumentStyle() { + Decoration *deco = pdoc->decorations.root; + while (deco) { + // Save next in case deco deleted + Decoration *decoNext = deco->next; + if (deco->indicator < INDIC_CONTAINER) { + pdoc->decorations.SetCurrentIndicator(deco->indicator); + pdoc->DecorationFillRange(0, 0, pdoc->Length()); + } + deco = decoNext; + } + pdoc->StartStyling(0, '\377'); + pdoc->SetStyleFor(pdoc->Length(), 0); + cs.ShowAll(); + pdoc->ClearLevels(); +} + +void Editor::CopyAllowLine() { + SelectionText selectedText; + CopySelectionRange(&selectedText, true); + CopyToClipboard(selectedText); +} + +void Editor::Cut() { + pdoc->CheckReadOnly(); + if (!pdoc->IsReadOnly() && !SelectionContainsProtected()) { + Copy(); + ClearSelection(); + } +} + +void Editor::PasteRectangular(SelectionPosition pos, const char *ptr, int len) { + if (pdoc->IsReadOnly() || SelectionContainsProtected()) { + return; + } + sel.Clear(); + sel.RangeMain() = SelectionRange(pos); + int line = pdoc->LineFromPosition(sel.MainCaret()); + UndoGroup ug(pdoc); + sel.RangeMain().caret = SelectionPosition( + InsertSpace(sel.RangeMain().caret.Position(), sel.RangeMain().caret.VirtualSpace())); + int xInsert = XFromPosition(sel.RangeMain().caret); + bool prevCr = false; + while ((len > 0) && IsEOLChar(ptr[len-1])) + len--; + for (int i = 0; i < len; i++) { + if (IsEOLChar(ptr[i])) { + if ((ptr[i] == '\r') || (!prevCr)) + line++; + if (line >= pdoc->LinesTotal()) { + if (pdoc->eolMode != SC_EOL_LF) + pdoc->InsertChar(pdoc->Length(), '\r'); + if (pdoc->eolMode != SC_EOL_CR) + pdoc->InsertChar(pdoc->Length(), '\n'); + } + // Pad the end of lines with spaces if required + sel.RangeMain().caret.SetPosition(PositionFromLineX(line, xInsert)); + if ((XFromPosition(sel.MainCaret()) < xInsert) && (i + 1 < len)) { + while (XFromPosition(sel.MainCaret()) < xInsert) { + pdoc->InsertChar(sel.MainCaret(), ' '); + sel.RangeMain().caret.Add(1); + } + } + prevCr = ptr[i] == '\r'; + } else { + pdoc->InsertString(sel.MainCaret(), ptr + i, 1); + sel.RangeMain().caret.Add(1); + prevCr = false; + } + } + SetEmptySelection(pos); +} + +bool Editor::CanPaste() { + return !pdoc->IsReadOnly() && !SelectionContainsProtected(); +} + +void Editor::Clear() { + // If multiple selections, don't delete EOLS + if (sel.Empty()) { + UndoGroup ug(pdoc, sel.Count() > 1); + for (size_t r=0; rCharAt(sel.Range(r).caret.Position()))) { + pdoc->DelChar(sel.Range(r).caret.Position()); + sel.Range(r).ClearVirtualSpace(); + } // else multiple selection so don't eat line ends + } else { + sel.Range(r).ClearVirtualSpace(); + } + } + } else { + ClearSelection(); + } + sel.RemoveDuplicates(); +} + +void Editor::SelectAll() { + sel.Clear(); + SetSelection(0, pdoc->Length()); + Redraw(); +} + +void Editor::Undo() { + if (pdoc->CanUndo()) { + InvalidateCaret(); + int newPos = pdoc->Undo(); + if (newPos >= 0) + SetEmptySelection(newPos); + EnsureCaretVisible(); + } +} + +void Editor::Redo() { + if (pdoc->CanRedo()) { + int newPos = pdoc->Redo(); + if (newPos >= 0) + SetEmptySelection(newPos); + EnsureCaretVisible(); + } +} + +void Editor::DelChar() { + if (!RangeContainsProtected(sel.MainCaret(), sel.MainCaret() + 1)) { + pdoc->DelChar(sel.MainCaret()); + } + // Avoid blinking during rapid typing: + ShowCaretAtCurrentPosition(); +} + +void Editor::DelCharBack(bool allowLineStartDeletion) { + if (!sel.IsRectangular()) + FilterSelections(); + if (sel.IsRectangular()) + allowLineStartDeletion = false; + UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty()); + if (sel.Empty()) { + for (size_t r=0; rLineFromPosition(sel.Range(r).caret.Position()); + if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != sel.Range(r).caret.Position())) { + if (pdoc->GetColumn(sel.Range(r).caret.Position()) <= pdoc->GetLineIndentation(lineCurrentPos) && + pdoc->GetColumn(sel.Range(r).caret.Position()) > 0 && pdoc->backspaceUnindents) { + UndoGroup ugInner(pdoc, !ug.Needed()); + int indentation = pdoc->GetLineIndentation(lineCurrentPos); + int indentationStep = pdoc->IndentSize(); + if (indentation % indentationStep == 0) { + pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep); + } else { + pdoc->SetLineIndentation(lineCurrentPos, indentation - (indentation % indentationStep)); + } + // SetEmptySelection + sel.Range(r) = SelectionRange(pdoc->GetLineIndentPosition(lineCurrentPos), + pdoc->GetLineIndentPosition(lineCurrentPos)); + } else { + pdoc->DelCharBack(sel.Range(r).caret.Position()); + } + } + } + } else { + sel.Range(r).ClearVirtualSpace(); + } + } + } else { + ClearSelection(); + } + sel.RemoveDuplicates(); + // Avoid blinking during rapid typing: + ShowCaretAtCurrentPosition(); +} + +void Editor::NotifyFocus(bool) {} + +void Editor::NotifyStyleToNeeded(int endStyleNeeded) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_STYLENEEDED; + scn.position = endStyleNeeded; + NotifyParent(scn); +} + +void Editor::NotifyStyleNeeded(Document*, void *, int endStyleNeeded) { + NotifyStyleToNeeded(endStyleNeeded); +} + +void Editor::NotifyChar(int ch) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_CHARADDED; + scn.ch = ch; + NotifyParent(scn); +} + +void Editor::NotifySavePoint(bool isSavePoint) { + SCNotification scn = {0}; + if (isSavePoint) { + scn.nmhdr.code = SCN_SAVEPOINTREACHED; + } else { + scn.nmhdr.code = SCN_SAVEPOINTLEFT; + } + NotifyParent(scn); +} + +void Editor::NotifyModifyAttempt() { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_MODIFYATTEMPTRO; + NotifyParent(scn); +} + +void Editor::NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_DOUBLECLICK; + scn.line = LineFromLocation(pt); + scn.position = PositionFromLocation(pt, true); + scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | + (alt ? SCI_ALT : 0); + NotifyParent(scn); +} + +void Editor::NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_HOTSPOTDOUBLECLICK; + scn.position = position; + scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | + (alt ? SCI_ALT : 0); + NotifyParent(scn); +} + +void Editor::NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_HOTSPOTCLICK; + scn.position = position; + scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | + (alt ? SCI_ALT : 0); + NotifyParent(scn); +} + +void Editor::NotifyUpdateUI() { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_UPDATEUI; + NotifyParent(scn); +} + +void Editor::NotifyPainted() { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_PAINTED; + NotifyParent(scn); +} + +void Editor::NotifyIndicatorClick(bool click, int position, bool shift, bool ctrl, bool alt) { + int mask = pdoc->decorations.AllOnFor(position); + if ((click && mask) || pdoc->decorations.clickNotified) { + SCNotification scn = {0}; + pdoc->decorations.clickNotified = click; + scn.nmhdr.code = click ? SCN_INDICATORCLICK : SCN_INDICATORRELEASE; + scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | (alt ? SCI_ALT : 0); + scn.position = position; + NotifyParent(scn); + } +} + +bool Editor::NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt) { + int marginClicked = -1; + int x = 0; + for (int margin = 0; margin < ViewStyle::margins; margin++) { + if ((pt.x > x) && (pt.x < x + vs.ms[margin].width)) + marginClicked = margin; + x += vs.ms[margin].width; + } + if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_MARGINCLICK; + scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | + (alt ? SCI_ALT : 0); + scn.position = pdoc->LineStart(LineFromLocation(pt)); + scn.margin = marginClicked; + NotifyParent(scn); + return true; + } else { + return false; + } +} + +void Editor::NotifyNeedShown(int pos, int len) { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_NEEDSHOWN; + scn.position = pos; + scn.length = len; + NotifyParent(scn); +} + +void Editor::NotifyDwelling(Point pt, bool state) { + SCNotification scn = {0}; + scn.nmhdr.code = state ? SCN_DWELLSTART : SCN_DWELLEND; + scn.position = PositionFromLocation(pt, true); + scn.x = pt.x; + scn.y = pt.y; + NotifyParent(scn); +} + +void Editor::NotifyZoom() { + SCNotification scn = {0}; + scn.nmhdr.code = SCN_ZOOM; + NotifyParent(scn); +} + +// Notifications from document +void Editor::NotifyModifyAttempt(Document*, void *) { + //Platform::DebugPrintf("** Modify Attempt\n"); + NotifyModifyAttempt(); +} + +void Editor::NotifySavePoint(Document*, void *, bool atSavePoint) { + //Platform::DebugPrintf("** Save Point %s\n", atSavePoint ? "On" : "Off"); + NotifySavePoint(atSavePoint); +} + +void Editor::CheckModificationForWrap(DocModification mh) { + if (mh.modificationType & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT)) { + llc.Invalidate(LineLayout::llCheckTextAndStyle); + if (wrapState != eWrapNone) { + int lineDoc = pdoc->LineFromPosition(mh.position); + int lines = Platform::Maximum(0, mh.linesAdded); + NeedWrapping(lineDoc, lineDoc + lines + 1); + } + // Fix up annotation heights + int lineDoc = pdoc->LineFromPosition(mh.position); + int lines = Platform::Maximum(0, mh.linesAdded); + SetAnnotationHeights(lineDoc, lineDoc + lines + 2); + } +} + +// Move a position so it is still after the same character as before the insertion. +static inline int MovePositionForInsertion(int position, int startInsertion, int length) { + if (position > startInsertion) { + return position + length; + } + return position; +} + +// Move a position so it is still after the same character as before the deletion if that +// character is still present else after the previous surviving character. +static inline int MovePositionForDeletion(int position, int startDeletion, int length) { + if (position > startDeletion) { + int endDeletion = startDeletion + length; + if (position > endDeletion) { + return position - length; + } else { + return startDeletion; + } + } else { + return position; + } +} + +void Editor::NotifyModified(Document*, DocModification mh, void *) { + needUpdateUI = true; + if (paintState == painting) { + CheckForChangeOutsidePaint(Range(mh.position, mh.position + mh.length)); + } + if (mh.modificationType & SC_MOD_CHANGELINESTATE) { + if (paintState == painting) { + CheckForChangeOutsidePaint( + Range(pdoc->LineStart(mh.line), pdoc->LineStart(mh.line + 1))); + } else { + // Could check that change is before last visible line. + Redraw(); + } + } + if (mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) { + if (mh.modificationType & SC_MOD_CHANGESTYLE) { + pdoc->IncrementStyleClock(); + } + if (paintState == notPainting) { + if (mh.position < pdoc->LineStart(topLine)) { + // Styling performed before this view + Redraw(); + } else { + InvalidateRange(mh.position, mh.position + mh.length); + } + } + if (mh.modificationType & SC_MOD_CHANGESTYLE) { + llc.Invalidate(LineLayout::llCheckTextAndStyle); + } + } else { + // Move selection and brace highlights + if (mh.modificationType & SC_MOD_INSERTTEXT) { + sel.MovePositions(true, mh.position, mh.length); + braces[0] = MovePositionForInsertion(braces[0], mh.position, mh.length); + braces[1] = MovePositionForInsertion(braces[1], mh.position, mh.length); + } else if (mh.modificationType & SC_MOD_DELETETEXT) { + sel.MovePositions(false, mh.position, mh.length); + braces[0] = MovePositionForDeletion(braces[0], mh.position, mh.length); + braces[1] = MovePositionForDeletion(braces[1], mh.position, mh.length); + } + if (cs.LinesDisplayed() < cs.LinesInDoc()) { + // Some lines are hidden so may need shown. + // TODO: check if the modified area is hidden. + if (mh.modificationType & SC_MOD_BEFOREINSERT) { + NotifyNeedShown(mh.position, 0); + } else if (mh.modificationType & SC_MOD_BEFOREDELETE) { + NotifyNeedShown(mh.position, mh.length); + } + } + if (mh.linesAdded != 0) { + // Update contraction state for inserted and removed lines + // lineOfPos should be calculated in context of state before modification, shouldn't it + int lineOfPos = pdoc->LineFromPosition(mh.position); + if (mh.linesAdded > 0) { + cs.InsertLines(lineOfPos, mh.linesAdded); + } else { + cs.DeleteLines(lineOfPos, -mh.linesAdded); + } + } + if (mh.modificationType & SC_MOD_CHANGEANNOTATION) { + int lineDoc = pdoc->LineFromPosition(mh.position); + if (vs.annotationVisible) { + cs.SetHeight(lineDoc, cs.GetHeight(lineDoc) + mh.annotationLinesAdded); + } + } + CheckModificationForWrap(mh); + if (mh.linesAdded != 0) { + // Avoid scrolling of display if change before current display + if (mh.position < posTopLine && !CanDeferToLastStep(mh)) { + int newTop = Platform::Clamp(topLine + mh.linesAdded, 0, MaxScrollPos()); + if (newTop != topLine) { + SetTopLine(newTop); + SetVerticalScrollPos(); + } + } + + //Platform::DebugPrintf("** %x Doc Changed\n", this); + // TODO: could invalidate from mh.startModification to end of screen + //InvalidateRange(mh.position, mh.position + mh.length); + if (paintState == notPainting && !CanDeferToLastStep(mh)) { + QueueStyling(pdoc->Length()); + Redraw(); + } + } else { + //Platform::DebugPrintf("** %x Line Changed %d .. %d\n", this, + // mh.position, mh.position + mh.length); + if (paintState == notPainting && mh.length && !CanEliminate(mh)) { + QueueStyling(mh.position + mh.length); + InvalidateRange(mh.position, mh.position + mh.length); + } + } + } + + if (mh.linesAdded != 0 && !CanDeferToLastStep(mh)) { + SetScrollBars(); + } + + if ((mh.modificationType & SC_MOD_CHANGEMARKER) || (mh.modificationType & SC_MOD_CHANGEMARGIN)) { + if ((paintState == notPainting) || !PaintContainsMargin()) { + if (mh.modificationType & SC_MOD_CHANGEFOLD) { + // Fold changes can affect the drawing of following lines so redraw whole margin + RedrawSelMargin(mh.line-1, true); + } else { + RedrawSelMargin(mh.line); + } + } + } + + // NOW pay the piper WRT "deferred" visual updates + if (IsLastStep(mh)) { + SetScrollBars(); + Redraw(); + } + + // If client wants to see this modification + if (mh.modificationType & modEventMask) { + if ((mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) == 0) { + // Real modification made to text of document. + NotifyChange(); // Send EN_CHANGE + } + + SCNotification scn = {0}; + scn.nmhdr.code = SCN_MODIFIED; + scn.position = mh.position; + scn.modificationType = mh.modificationType; + scn.text = mh.text; + scn.length = mh.length; + scn.linesAdded = mh.linesAdded; + scn.line = mh.line; + scn.foldLevelNow = mh.foldLevelNow; + scn.foldLevelPrev = mh.foldLevelPrev; + scn.token = mh.token; + scn.annotationLinesAdded = mh.annotationLinesAdded; + NotifyParent(scn); + } +} + +void Editor::NotifyDeleted(Document *, void *) { + /* Do nothing */ +} + +void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam) { + + // Enumerates all macroable messages + switch (iMessage) { + case SCI_CUT: + case SCI_COPY: + case SCI_PASTE: + case SCI_CLEAR: + case SCI_REPLACESEL: + case SCI_ADDTEXT: + case SCI_INSERTTEXT: + case SCI_APPENDTEXT: + case SCI_CLEARALL: + case SCI_SELECTALL: + case SCI_GOTOLINE: + case SCI_GOTOPOS: + case SCI_SEARCHANCHOR: + case SCI_SEARCHNEXT: + case SCI_SEARCHPREV: + case SCI_LINEDOWN: + case SCI_LINEDOWNEXTEND: + case SCI_PARADOWN: + case SCI_PARADOWNEXTEND: + case SCI_LINEUP: + case SCI_LINEUPEXTEND: + case SCI_PARAUP: + case SCI_PARAUPEXTEND: + case SCI_CHARLEFT: + case SCI_CHARLEFTEXTEND: + case SCI_CHARRIGHT: + case SCI_CHARRIGHTEXTEND: + case SCI_WORDLEFT: + case SCI_WORDLEFTEXTEND: + case SCI_WORDRIGHT: + case SCI_WORDRIGHTEXTEND: + case SCI_WORDPARTLEFT: + case SCI_WORDPARTLEFTEXTEND: + case SCI_WORDPARTRIGHT: + case SCI_WORDPARTRIGHTEXTEND: + case SCI_WORDLEFTEND: + case SCI_WORDLEFTENDEXTEND: + case SCI_WORDRIGHTEND: + case SCI_WORDRIGHTENDEXTEND: + case SCI_HOME: + case SCI_HOMEEXTEND: + case SCI_LINEEND: + case SCI_LINEENDEXTEND: + case SCI_HOMEWRAP: + case SCI_HOMEWRAPEXTEND: + case SCI_LINEENDWRAP: + case SCI_LINEENDWRAPEXTEND: + case SCI_DOCUMENTSTART: + case SCI_DOCUMENTSTARTEXTEND: + case SCI_DOCUMENTEND: + case SCI_DOCUMENTENDEXTEND: + case SCI_STUTTEREDPAGEUP: + case SCI_STUTTEREDPAGEUPEXTEND: + case SCI_STUTTEREDPAGEDOWN: + case SCI_STUTTEREDPAGEDOWNEXTEND: + case SCI_PAGEUP: + case SCI_PAGEUPEXTEND: + case SCI_PAGEDOWN: + case SCI_PAGEDOWNEXTEND: + case SCI_EDITTOGGLEOVERTYPE: + case SCI_CANCEL: + case SCI_DELETEBACK: + case SCI_TAB: + case SCI_BACKTAB: + case SCI_FORMFEED: + case SCI_VCHOME: + case SCI_VCHOMEEXTEND: + case SCI_VCHOMEWRAP: + case SCI_VCHOMEWRAPEXTEND: + case SCI_DELWORDLEFT: + case SCI_DELWORDRIGHT: + case SCI_DELWORDRIGHTEND: + case SCI_DELLINELEFT: + case SCI_DELLINERIGHT: + case SCI_LINECOPY: + case SCI_LINECUT: + case SCI_LINEDELETE: + case SCI_LINETRANSPOSE: + case SCI_LINEDUPLICATE: + case SCI_LOWERCASE: + case SCI_UPPERCASE: + case SCI_LINESCROLLDOWN: + case SCI_LINESCROLLUP: + case SCI_DELETEBACKNOTLINE: + case SCI_HOMEDISPLAY: + case SCI_HOMEDISPLAYEXTEND: + case SCI_LINEENDDISPLAY: + case SCI_LINEENDDISPLAYEXTEND: + case SCI_SETSELECTIONMODE: + case SCI_LINEDOWNRECTEXTEND: + case SCI_LINEUPRECTEXTEND: + case SCI_CHARLEFTRECTEXTEND: + case SCI_CHARRIGHTRECTEXTEND: + case SCI_HOMERECTEXTEND: + case SCI_VCHOMERECTEXTEND: + case SCI_LINEENDRECTEXTEND: + case SCI_PAGEUPRECTEXTEND: + case SCI_PAGEDOWNRECTEXTEND: + case SCI_SELECTIONDUPLICATE: + case SCI_COPYALLOWLINE: + break; + + // Filter out all others like display changes. Also, newlines are redundant + // with char insert messages. + case SCI_NEWLINE: + default: + // printf("Filtered out %ld of macro recording\n", iMessage); + return ; + } + + // Send notification + SCNotification scn = {0}; + scn.nmhdr.code = SCN_MACRORECORD; + scn.message = iMessage; + scn.wParam = wParam; + scn.lParam = lParam; + NotifyParent(scn); +} + +/** + * Force scroll and keep position relative to top of window. + * + * If stuttered = true and not already at first/last row, move to first/last row of window. + * If stuttered = true and already at first/last row, scroll as normal. + */ +void Editor::PageMove(int direction, Selection::selTypes selt, bool stuttered) { + int topLineNew, newPos; + + // I consider only the caretYSlop, and ignore the caretYPolicy-- is that a problem? + int currentLine = pdoc->LineFromPosition(sel.MainCaret()); + int topStutterLine = topLine + caretYSlop; + int bottomStutterLine = + pdoc->LineFromPosition(PositionFromLocation( + Point(lastXChosen - xOffset, direction * vs.lineHeight * LinesToScroll()))) + - caretYSlop - 1; + + if (stuttered && (direction < 0 && currentLine > topStutterLine)) { + topLineNew = topLine; + newPos = PositionFromLocation(Point(lastXChosen - xOffset, vs.lineHeight * caretYSlop)); + + } else if (stuttered && (direction > 0 && currentLine < bottomStutterLine)) { + topLineNew = topLine; + newPos = PositionFromLocation(Point(lastXChosen - xOffset, vs.lineHeight * (LinesToScroll() - caretYSlop))); + + } else { + Point pt = LocationFromPosition(sel.MainCaret()); + + topLineNew = Platform::Clamp( + topLine + direction * LinesToScroll(), 0, MaxScrollPos()); + newPos = PositionFromLocation( + Point(lastXChosen - xOffset, pt.y + direction * (vs.lineHeight * LinesToScroll()))); + } + + if (topLineNew != topLine) { + SetTopLine(topLineNew); + MovePositionTo(SelectionPosition(newPos), selt); + Redraw(); + SetVerticalScrollPos(); + } else { + MovePositionTo(SelectionPosition(newPos), selt); + } +} + +void Editor::ChangeCaseOfSelection(int caseMapping) { + UndoGroup ug(pdoc); + for (size_t r=0; r 0) { + std::string sText(text, rangeBytes); + + std::string sMapped = CaseMapString(sText, caseMapping); + + if (sMapped != sText) { + size_t firstDifference = 0; + while (sMapped[firstDifference] == sText[firstDifference]) + firstDifference++; + size_t lastDifference = sMapped.size() - 1; + while (sMapped[lastDifference] == sText[lastDifference]) + lastDifference--; + size_t endSame = sMapped.size() - 1 - lastDifference; + pdoc->DeleteChars(currentNoVS.Start().Position() + firstDifference, + rangeBytes - firstDifference - endSame); + pdoc->InsertString(currentNoVS.Start().Position() + firstDifference, + sMapped.c_str() + firstDifference, lastDifference - firstDifference + 1); + // Automatic movement changes selection so reset to exactly the same as it was. + sel.Range(r) = current; + } +} + delete []text; + } +} + +void Editor::LineTranspose() { + int line = pdoc->LineFromPosition(sel.MainCaret()); + if (line > 0) { + UndoGroup ug(pdoc); + int startPrev = pdoc->LineStart(line - 1); + int endPrev = pdoc->LineEnd(line - 1); + int start = pdoc->LineStart(line); + int end = pdoc->LineEnd(line); + char *line1 = CopyRange(startPrev, endPrev); + int len1 = endPrev - startPrev; + char *line2 = CopyRange(start, end); + int len2 = end - start; + pdoc->DeleteChars(start, len2); + pdoc->DeleteChars(startPrev, len1); + pdoc->InsertString(startPrev, line2, len2); + pdoc->InsertString(start - len1 + len2, line1, len1); + MovePositionTo(SelectionPosition(start - len1 + len2)); + delete []line1; + delete []line2; + } +} + +void Editor::Duplicate(bool forLine) { + if (sel.Empty()) { + forLine = true; + } + UndoGroup ug(pdoc, sel.Count() > 1); + SelectionPosition last; + const char *eol = ""; + int eolLen = 0; + if (forLine) { + eol = StringFromEOLMode(pdoc->eolMode); + eolLen = istrlen(eol); + } + for (size_t r=0; rLineFromPosition(sel.Range(r).caret.Position()); + start = SelectionPosition(pdoc->LineStart(line)); + end = SelectionPosition(pdoc->LineEnd(line)); + } + char *text = CopyRange(start.Position(), end.Position()); + if (forLine) + pdoc->InsertString(end.Position(), eol, eolLen); + pdoc->InsertString(end.Position() + eolLen, text, SelectionRange(end, start).Length()); + delete []text; + } + if (sel.Count() && sel.IsRectangular()) { + SelectionPosition last = sel.Last(); + if (forLine) { + int line = pdoc->LineFromPosition(last.Position()); + last = SelectionPosition(last.Position() + pdoc->LineStart(line+1) - pdoc->LineStart(line)); + } + if (sel.Rectangular().anchor > sel.Rectangular().caret) + sel.Rectangular().anchor = last; + else + sel.Rectangular().caret = last; + SetRectangularRange(); + } +} + +void Editor::CancelModes() { + sel.SetMoveExtends(false); +} + +void Editor::NewLine() { + ClearSelection(); + const char *eol = "\n"; + if (pdoc->eolMode == SC_EOL_CRLF) { + eol = "\r\n"; + } else if (pdoc->eolMode == SC_EOL_CR) { + eol = "\r"; + } // else SC_EOL_LF -> "\n" already set + if (pdoc->InsertCString(sel.MainCaret(), eol)) { + SetEmptySelection(sel.MainCaret() + istrlen(eol)); + while (*eol) { + NotifyChar(*eol); + if (recordingMacro) { + char txt[2]; + txt[0] = *eol; + txt[1] = '\0'; + NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast(txt)); + } + eol++; + } + } + SetLastXChosen(); + SetScrollBars(); + EnsureCaretVisible(); + // Avoid blinking during rapid typing: + ShowCaretAtCurrentPosition(); +} + +void Editor::CursorUpOrDown(int direction, Selection::selTypes selt) { + SelectionPosition caretToUse = sel.Range(sel.Main()).caret; + if (sel.IsRectangular()) { + if (selt == Selection::noSel) { + caretToUse = (direction > 0) ? sel.Limits().end : sel.Limits().start; + } else { + caretToUse = sel.Rectangular().caret; + } + } + Point pt = LocationFromPosition(caretToUse); + int lineDoc = pdoc->LineFromPosition(caretToUse.Position()); + Point ptStartLine = LocationFromPosition(pdoc->LineStart(lineDoc)); + int subLine = (pt.y - ptStartLine.y) / vs.lineHeight; + int commentLines = vs.annotationVisible ? pdoc->AnnotationLines(lineDoc) : 0; + SelectionPosition posNew = SPositionFromLocation( + Point(lastXChosen - xOffset, pt.y + direction * vs.lineHeight), false, false, UserVirtualSpace()); + if ((direction > 0) && (subLine >= (cs.GetHeight(lineDoc) - 1 - commentLines))) { + posNew = SPositionFromLocation( + Point(lastXChosen - xOffset, pt.y + (commentLines + 1) * vs.lineHeight), false, false, UserVirtualSpace()); + } + if (direction < 0) { + // Line wrapping may lead to a location on the same line, so + // seek back if that is the case. + // There is an equivalent case when moving down which skips + // over a line but as that does not trap the user it is fine. + Point ptNew = LocationFromPosition(posNew.Position()); + while ((posNew.Position() > 0) && (pt.y == ptNew.y)) { + posNew.Add(- 1); + posNew.SetVirtualSpace(0); + ptNew = LocationFromPosition(posNew.Position()); + } + } + MovePositionTo(posNew, selt); +} + +void Editor::ParaUpOrDown(int direction, Selection::selTypes selt) { + int lineDoc, savedPos = sel.MainCaret(); + do { + MovePositionTo(SelectionPosition(direction > 0 ? pdoc->ParaDown(sel.MainCaret()) : pdoc->ParaUp(sel.MainCaret())), selt); + lineDoc = pdoc->LineFromPosition(sel.MainCaret()); + if (direction > 0) { + if (sel.MainCaret() >= pdoc->Length() && !cs.GetVisible(lineDoc)) { + if (selt == Selection::noSel) { + MovePositionTo(SelectionPosition(pdoc->LineEndPosition(savedPos))); + } + break; + } + } + } while (!cs.GetVisible(lineDoc)); +} + +int Editor::StartEndDisplayLine(int pos, bool start) { + RefreshStyleData(); + int line = pdoc->LineFromPosition(pos); + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(line)); + int posRet = INVALID_POSITION; + if (surface && ll) { + unsigned int posLineStart = pdoc->LineStart(line); + LayoutLine(line, surface, vs, ll, wrapWidth); + int posInLine = pos - posLineStart; + if (posInLine <= ll->maxLineLength) { + for (int subLine = 0; subLine < ll->lines; subLine++) { + if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) { + if (start) { + posRet = ll->LineStart(subLine) + posLineStart; + } else { + if (subLine == ll->lines - 1) + posRet = ll->LineStart(subLine + 1) + posLineStart; + else + posRet = ll->LineStart(subLine + 1) + posLineStart - 1; + } + } + } + } + } + if (posRet == INVALID_POSITION) { + return pos; + } else { + return posRet; + } +} + +int Editor::KeyCommand(unsigned int iMessage) { + switch (iMessage) { + case SCI_LINEDOWN: + CursorUpOrDown(1); + break; + case SCI_LINEDOWNEXTEND: + CursorUpOrDown(1, Selection::selStream); + break; + case SCI_LINEDOWNRECTEXTEND: + CursorUpOrDown(1, Selection::selRectangle); + break; + case SCI_PARADOWN: + ParaUpOrDown(1); + break; + case SCI_PARADOWNEXTEND: + ParaUpOrDown(1, Selection::selStream); + break; + case SCI_LINESCROLLDOWN: + ScrollTo(topLine + 1); + MoveCaretInsideView(false); + break; + case SCI_LINEUP: + CursorUpOrDown(-1); + break; + case SCI_LINEUPEXTEND: + CursorUpOrDown(-1, Selection::selStream); + break; + case SCI_LINEUPRECTEXTEND: + CursorUpOrDown(-1, Selection::selRectangle); + break; + case SCI_PARAUP: + ParaUpOrDown(-1); + break; + case SCI_PARAUPEXTEND: + ParaUpOrDown(-1, Selection::selStream); + break; + case SCI_LINESCROLLUP: + ScrollTo(topLine - 1); + MoveCaretInsideView(false); + break; + case SCI_CHARLEFT: + if (SelectionEmpty() || sel.MoveExtends()) { + if ((sel.Count() == 1) && pdoc->IsLineEndPosition(sel.MainCaret()) && sel.RangeMain().caret.VirtualSpace()) { + SelectionPosition spCaret = sel.RangeMain().caret; + spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1); + MovePositionTo(spCaret); + } else { + MovePositionTo(MovePositionSoVisible( + SelectionPosition((sel.LimitsForRectangularElseMain().start).Position() - 1), -1)); + } + } else { + MovePositionTo(sel.LimitsForRectangularElseMain().start); + } + SetLastXChosen(); + break; + case SCI_CHARLEFTEXTEND: + if (pdoc->IsLineEndPosition(sel.MainCaret()) && sel.RangeMain().caret.VirtualSpace()) { + SelectionPosition spCaret = sel.RangeMain().caret; + spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1); + MovePositionTo(spCaret, Selection::selStream); + } else { + MovePositionTo(MovePositionSoVisible(SelectionPosition(sel.MainCaret() - 1), -1), Selection::selStream); + } + SetLastXChosen(); + break; + case SCI_CHARLEFTRECTEXTEND: + if (pdoc->IsLineEndPosition(sel.MainCaret()) && sel.RangeMain().caret.VirtualSpace()) { + SelectionPosition spCaret = sel.RangeMain().caret; + spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1); + MovePositionTo(spCaret, Selection::selRectangle); + } else { + MovePositionTo(MovePositionSoVisible(SelectionPosition(sel.MainCaret() - 1), -1), Selection::selRectangle); + } + SetLastXChosen(); + break; + case SCI_CHARRIGHT: + if (SelectionEmpty() || sel.MoveExtends()) { + if ((virtualSpaceOptions & SCVS_USERACCESSIBLE) && pdoc->IsLineEndPosition(sel.MainCaret())) { + SelectionPosition spCaret = sel.RangeMain().caret; + spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1); + MovePositionTo(spCaret); + } else { + MovePositionTo(MovePositionSoVisible( + SelectionPosition((sel.LimitsForRectangularElseMain().end).Position() + 1), 1)); + } + } else { + MovePositionTo(sel.LimitsForRectangularElseMain().end); + } + SetLastXChosen(); + break; + case SCI_CHARRIGHTEXTEND: + if ((virtualSpaceOptions & SCVS_USERACCESSIBLE) && pdoc->IsLineEndPosition(sel.MainCaret())) { + SelectionPosition spCaret = sel.RangeMain().caret; + spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1); + MovePositionTo(spCaret, Selection::selStream); + } else { + MovePositionTo(MovePositionSoVisible(SelectionPosition(sel.MainCaret() + 1), 1), Selection::selStream); + } + SetLastXChosen(); + break; + case SCI_CHARRIGHTRECTEXTEND: + if ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) && pdoc->IsLineEndPosition(sel.MainCaret())) { + SelectionPosition spCaret = sel.RangeMain().caret; + spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1); + MovePositionTo(spCaret, Selection::selRectangle); + } else { + MovePositionTo(MovePositionSoVisible(SelectionPosition(sel.MainCaret() + 1), 1), Selection::selRectangle); + } + SetLastXChosen(); + break; + case SCI_WORDLEFT: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(sel.MainCaret(), -1), -1)); + SetLastXChosen(); + break; + case SCI_WORDLEFTEXTEND: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(sel.MainCaret(), -1), -1), Selection::selStream); + SetLastXChosen(); + break; + case SCI_WORDRIGHT: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(sel.MainCaret(), 1), 1)); + SetLastXChosen(); + break; + case SCI_WORDRIGHTEXTEND: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(sel.MainCaret(), 1), 1), Selection::selStream); + SetLastXChosen(); + break; + + case SCI_WORDLEFTEND: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(sel.MainCaret(), -1), -1)); + SetLastXChosen(); + break; + case SCI_WORDLEFTENDEXTEND: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(sel.MainCaret(), -1), -1), Selection::selStream); + SetLastXChosen(); + break; + case SCI_WORDRIGHTEND: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(sel.MainCaret(), 1), 1)); + SetLastXChosen(); + break; + case SCI_WORDRIGHTENDEXTEND: + MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(sel.MainCaret(), 1), 1), Selection::selStream); + SetLastXChosen(); + break; + + case SCI_HOME: + MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret()))); + SetLastXChosen(); + break; + case SCI_HOMEEXTEND: + MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret())), Selection::selStream); + SetLastXChosen(); + break; + case SCI_HOMERECTEXTEND: + MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret())), Selection::selRectangle); + SetLastXChosen(); + break; + case SCI_LINEEND: + MovePositionTo(pdoc->LineEndPosition(sel.MainCaret())); + SetLastXChosen(); + break; + case SCI_LINEENDEXTEND: + MovePositionTo(pdoc->LineEndPosition(sel.MainCaret()), Selection::selStream); + SetLastXChosen(); + break; + case SCI_LINEENDRECTEXTEND: + MovePositionTo(pdoc->LineEndPosition(sel.MainCaret()), Selection::selRectangle); + SetLastXChosen(); + break; + case SCI_HOMEWRAP: { + SelectionPosition homePos = MovePositionSoVisible(StartEndDisplayLine(sel.MainCaret(), true), -1); + if (sel.RangeMain().caret <= homePos) + homePos = SelectionPosition(pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret()))); + MovePositionTo(homePos); + SetLastXChosen(); + } + break; + case SCI_HOMEWRAPEXTEND: { + SelectionPosition homePos = MovePositionSoVisible(StartEndDisplayLine(sel.MainCaret(), true), -1); + if (sel.RangeMain().caret <= homePos) + homePos = SelectionPosition(pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret()))); + MovePositionTo(homePos, Selection::selStream); + SetLastXChosen(); + } + break; + case SCI_LINEENDWRAP: { + SelectionPosition endPos = MovePositionSoVisible(StartEndDisplayLine(sel.MainCaret(), false), 1); + SelectionPosition realEndPos = SelectionPosition(pdoc->LineEndPosition(sel.MainCaret())); + if (endPos > realEndPos // if moved past visible EOLs + || sel.RangeMain().caret >= endPos) // if at end of display line already + endPos = realEndPos; + MovePositionTo(endPos); + SetLastXChosen(); + } + break; + case SCI_LINEENDWRAPEXTEND: { + SelectionPosition endPos = MovePositionSoVisible(StartEndDisplayLine(sel.MainCaret(), false), 1); + SelectionPosition realEndPos = SelectionPosition(pdoc->LineEndPosition(sel.MainCaret())); + if (endPos > realEndPos // if moved past visible EOLs + || sel.RangeMain().caret >= endPos) // if at end of display line already + endPos = realEndPos; + MovePositionTo(endPos, Selection::selStream); + SetLastXChosen(); + } + break; + case SCI_DOCUMENTSTART: + MovePositionTo(0); + SetLastXChosen(); + break; + case SCI_DOCUMENTSTARTEXTEND: + MovePositionTo(0, Selection::selStream); + SetLastXChosen(); + break; + case SCI_DOCUMENTEND: + MovePositionTo(pdoc->Length()); + SetLastXChosen(); + break; + case SCI_DOCUMENTENDEXTEND: + MovePositionTo(pdoc->Length(), Selection::selStream); + SetLastXChosen(); + break; + case SCI_STUTTEREDPAGEUP: + PageMove(-1, Selection::noSel, true); + break; + case SCI_STUTTEREDPAGEUPEXTEND: + PageMove(-1, Selection::selStream, true); + break; + case SCI_STUTTEREDPAGEDOWN: + PageMove(1, Selection::noSel, true); + break; + case SCI_STUTTEREDPAGEDOWNEXTEND: + PageMove(1, Selection::selStream, true); + break; + case SCI_PAGEUP: + PageMove(-1); + break; + case SCI_PAGEUPEXTEND: + PageMove(-1, Selection::selStream); + break; + case SCI_PAGEUPRECTEXTEND: + PageMove(-1, Selection::selRectangle); + break; + case SCI_PAGEDOWN: + PageMove(1); + break; + case SCI_PAGEDOWNEXTEND: + PageMove(1, Selection::selStream); + break; + case SCI_PAGEDOWNRECTEXTEND: + PageMove(1, Selection::selRectangle); + break; + case SCI_EDITTOGGLEOVERTYPE: + inOverstrike = !inOverstrike; + DropCaret(); + ShowCaretAtCurrentPosition(); + NotifyUpdateUI(); + break; + case SCI_CANCEL: // Cancel any modes - handled in subclass + // Also unselect text + CancelModes(); + break; + case SCI_DELETEBACK: + DelCharBack(true); + if (!caretSticky) { + SetLastXChosen(); + } + EnsureCaretVisible(); + break; + case SCI_DELETEBACKNOTLINE: + DelCharBack(false); + if (!caretSticky) { + SetLastXChosen(); + } + EnsureCaretVisible(); + break; + case SCI_TAB: + Indent(true); + if (!caretSticky) { + SetLastXChosen(); + } + EnsureCaretVisible(); + ShowCaretAtCurrentPosition(); // Avoid blinking + break; + case SCI_BACKTAB: + Indent(false); + if (!caretSticky) { + SetLastXChosen(); + } + EnsureCaretVisible(); + ShowCaretAtCurrentPosition(); // Avoid blinking + break; + case SCI_NEWLINE: + NewLine(); + break; + case SCI_FORMFEED: + AddChar('\f'); + break; + case SCI_VCHOME: + MovePositionTo(pdoc->VCHomePosition(sel.MainCaret())); + SetLastXChosen(); + break; + case SCI_VCHOMEEXTEND: + MovePositionTo(pdoc->VCHomePosition(sel.MainCaret()), Selection::selStream); + SetLastXChosen(); + break; + case SCI_VCHOMERECTEXTEND: + MovePositionTo(pdoc->VCHomePosition(sel.MainCaret()), Selection::selRectangle); + SetLastXChosen(); + break; + case SCI_VCHOMEWRAP: { + SelectionPosition homePos = SelectionPosition(pdoc->VCHomePosition(sel.MainCaret())); + SelectionPosition viewLineStart = MovePositionSoVisible(StartEndDisplayLine(sel.MainCaret(), true), -1); + if ((viewLineStart < sel.RangeMain().caret) && (viewLineStart > homePos)) + homePos = viewLineStart; + + MovePositionTo(homePos); + SetLastXChosen(); + } + break; + case SCI_VCHOMEWRAPEXTEND: { + SelectionPosition homePos = SelectionPosition(pdoc->VCHomePosition(sel.MainCaret())); + SelectionPosition viewLineStart = MovePositionSoVisible(StartEndDisplayLine(sel.MainCaret(), true), -1); + if ((viewLineStart < sel.RangeMain().caret) && (viewLineStart > homePos)) + homePos = viewLineStart; + + MovePositionTo(homePos, Selection::selStream); + SetLastXChosen(); + } + break; + case SCI_ZOOMIN: + if (vs.zoomLevel < 20) { + vs.zoomLevel++; + InvalidateStyleRedraw(); + NotifyZoom(); + } + break; + case SCI_ZOOMOUT: + if (vs.zoomLevel > -10) { + vs.zoomLevel--; + InvalidateStyleRedraw(); + NotifyZoom(); + } + break; + case SCI_DELWORDLEFT: { + int startWord = pdoc->NextWordStart(sel.MainCaret(), -1); + pdoc->DeleteChars(startWord, sel.MainCaret() - startWord); + sel.RangeMain().ClearVirtualSpace(); + SetLastXChosen(); + } + break; + case SCI_DELWORDRIGHT: { + UndoGroup ug(pdoc); + sel.RangeMain().caret = SelectionPosition( + InsertSpace(sel.RangeMain().caret.Position(), sel.RangeMain().caret.VirtualSpace())); + int endWord = pdoc->NextWordStart(sel.MainCaret(), 1); + pdoc->DeleteChars(sel.MainCaret(), endWord - sel.MainCaret()); + } + break; + case SCI_DELWORDRIGHTEND: { + UndoGroup ug(pdoc); + sel.RangeMain().caret = SelectionPosition( + InsertSpace(sel.RangeMain().caret.Position(), sel.RangeMain().caret.VirtualSpace())); + int endWord = pdoc->NextWordEnd(sel.MainCaret(), 1); + pdoc->DeleteChars(sel.MainCaret(), endWord - sel.MainCaret()); + } + break; + case SCI_DELLINELEFT: { + int line = pdoc->LineFromPosition(sel.MainCaret()); + int start = pdoc->LineStart(line); + pdoc->DeleteChars(start, sel.MainCaret() - start); + sel.RangeMain().ClearVirtualSpace(); + SetLastXChosen(); + } + break; + case SCI_DELLINERIGHT: { + int line = pdoc->LineFromPosition(sel.MainCaret()); + int end = pdoc->LineEnd(line); + pdoc->DeleteChars(sel.MainCaret(), end - sel.MainCaret()); + } + break; + case SCI_LINECOPY: { + int lineStart = pdoc->LineFromPosition(SelectionStart().Position()); + int lineEnd = pdoc->LineFromPosition(SelectionEnd().Position()); + CopyRangeToClipboard(pdoc->LineStart(lineStart), + pdoc->LineStart(lineEnd + 1)); + } + break; + case SCI_LINECUT: { + int lineStart = pdoc->LineFromPosition(SelectionStart().Position()); + int lineEnd = pdoc->LineFromPosition(SelectionEnd().Position()); + int start = pdoc->LineStart(lineStart); + int end = pdoc->LineStart(lineEnd + 1); + SetSelection(start, end); + Cut(); + SetLastXChosen(); + } + break; + case SCI_LINEDELETE: { + int line = pdoc->LineFromPosition(sel.MainCaret()); + int start = pdoc->LineStart(line); + int end = pdoc->LineStart(line + 1); + pdoc->DeleteChars(start, end - start); + } + break; + case SCI_LINETRANSPOSE: + LineTranspose(); + break; + case SCI_LINEDUPLICATE: + Duplicate(true); + break; + case SCI_SELECTIONDUPLICATE: + Duplicate(false); + break; + case SCI_LOWERCASE: + ChangeCaseOfSelection(cmLower); + break; + case SCI_UPPERCASE: + ChangeCaseOfSelection(cmUpper); + break; + case SCI_WORDPARTLEFT: + MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(sel.MainCaret()), -1)); + SetLastXChosen(); + break; + case SCI_WORDPARTLEFTEXTEND: + MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(sel.MainCaret()), -1), Selection::selStream); + SetLastXChosen(); + break; + case SCI_WORDPARTRIGHT: + MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(sel.MainCaret()), 1)); + SetLastXChosen(); + break; + case SCI_WORDPARTRIGHTEXTEND: + MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(sel.MainCaret()), 1), Selection::selStream); + SetLastXChosen(); + break; + case SCI_HOMEDISPLAY: + MovePositionTo(MovePositionSoVisible( + StartEndDisplayLine(sel.MainCaret(), true), -1)); + SetLastXChosen(); + break; + case SCI_HOMEDISPLAYEXTEND: + MovePositionTo(MovePositionSoVisible( + StartEndDisplayLine(sel.MainCaret(), true), -1), Selection::selStream); + SetLastXChosen(); + break; + case SCI_LINEENDDISPLAY: + MovePositionTo(MovePositionSoVisible( + StartEndDisplayLine(sel.MainCaret(), false), 1)); + SetLastXChosen(); + break; + case SCI_LINEENDDISPLAYEXTEND: + MovePositionTo(MovePositionSoVisible( + StartEndDisplayLine(sel.MainCaret(), false), 1), Selection::selStream); + SetLastXChosen(); + break; + } + return 0; +} + +int Editor::KeyDefault(int, int) { + return 0; +} + +int Editor::KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed) { + DwellEnd(false); + int modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | + (alt ? SCI_ALT : 0); + int msg = kmap.Find(key, modifiers); + if (msg) { + if (consumed) + *consumed = true; + return WndProc(msg, 0, 0); + } else { + if (consumed) + *consumed = false; + return KeyDefault(key, modifiers); + } +} + +void Editor::SetWhitespaceVisible(int view) { + vs.viewWhitespace = static_cast(view); +} + +int Editor::GetWhitespaceVisible() { + return vs.viewWhitespace; +} + +void Editor::Indent(bool forwards) { + for (size_t r=0; rLineFromPosition(sel.Range(r).anchor.Position()); + int caretPosition = sel.Range(r).caret.Position(); + int lineCurrentPos = pdoc->LineFromPosition(caretPosition); + if (lineOfAnchor == lineCurrentPos) { + if (forwards) { + UndoGroup ug(pdoc); + pdoc->DeleteChars(sel.Range(r).Start().Position(), sel.Range(r).Length()); + caretPosition = sel.Range(r).caret.Position(); + if (pdoc->GetColumn(caretPosition) <= pdoc->GetColumn(pdoc->GetLineIndentPosition(lineCurrentPos)) && + pdoc->tabIndents) { + int indentation = pdoc->GetLineIndentation(lineCurrentPos); + int indentationStep = pdoc->IndentSize(); + pdoc->SetLineIndentation(lineCurrentPos, indentation + indentationStep - indentation % indentationStep); + sel.Range(r) = SelectionRange(pdoc->GetLineIndentPosition(lineCurrentPos)); + } else { + if (pdoc->useTabs) { + pdoc->InsertChar(caretPosition, '\t'); + sel.Range(r) = SelectionRange(caretPosition+1); + } else { + int numSpaces = (pdoc->tabInChars) - + (pdoc->GetColumn(caretPosition) % (pdoc->tabInChars)); + if (numSpaces < 1) + numSpaces = pdoc->tabInChars; + for (int i = 0; i < numSpaces; i++) { + pdoc->InsertChar(caretPosition + i, ' '); + } + sel.Range(r) = SelectionRange(caretPosition+numSpaces); + } + } + } else { + if (pdoc->GetColumn(caretPosition) <= pdoc->GetLineIndentation(lineCurrentPos) && + pdoc->tabIndents) { + UndoGroup ug(pdoc); + int indentation = pdoc->GetLineIndentation(lineCurrentPos); + int indentationStep = pdoc->IndentSize(); + pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep); + sel.Range(r) = SelectionRange(pdoc->GetLineIndentPosition(lineCurrentPos)); + } else { + int newColumn = ((pdoc->GetColumn(caretPosition) - 1) / pdoc->tabInChars) * + pdoc->tabInChars; + if (newColumn < 0) + newColumn = 0; + int newPos = caretPosition; + while (pdoc->GetColumn(newPos) > newColumn) + newPos--; + sel.Range(r) = SelectionRange(newPos); + } + } + } else { // Multiline + int anchorPosOnLine = sel.Range(r).anchor.Position() - pdoc->LineStart(lineOfAnchor); + int currentPosPosOnLine = caretPosition - pdoc->LineStart(lineCurrentPos); + // Multiple lines selected so indent / dedent + int lineTopSel = Platform::Minimum(lineOfAnchor, lineCurrentPos); + int lineBottomSel = Platform::Maximum(lineOfAnchor, lineCurrentPos); + if (pdoc->LineStart(lineBottomSel) == sel.Range(r).anchor.Position() || pdoc->LineStart(lineBottomSel) == caretPosition) + lineBottomSel--; // If not selecting any characters on a line, do not indent + { + UndoGroup ug(pdoc); + pdoc->Indent(forwards, lineBottomSel, lineTopSel); + } + if (lineOfAnchor < lineCurrentPos) { + if (currentPosPosOnLine == 0) + sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor)); + else + sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos + 1), pdoc->LineStart(lineOfAnchor)); + } else { + if (anchorPosOnLine == 0) + sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor)); + else + sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor + 1)); + } + } + } +} + +class CaseFolderASCII : public CaseFolderTable { +public: + CaseFolderASCII() { + StandardASCII(); + } + ~CaseFolderASCII() { + } + virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) { + if (lenMixed > sizeFolded) { + return 0; + } else { + for (size_t i=0; i(mixed[i])]; + } + return lenMixed; + } + } +}; + + +CaseFolder *Editor::CaseFolderForEncoding() { + // Simple default that only maps ASCII upper case to lower case. + return new CaseFolderASCII(); +} + +/** + * Search of a text in the document, in the given range. + * @return The position of the found text, -1 if not found. + */ +long Editor::FindText( + uptr_t wParam, ///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD, + ///< @c SCFIND_WORDSTART, @c SCFIND_REGEXP or @c SCFIND_POSIX. + sptr_t lParam) { ///< @c TextToFind structure: The text to search for in the given range. + + Sci_TextToFind *ft = reinterpret_cast(lParam); + int lengthFound = istrlen(ft->lpstrText); + std::auto_ptr pcf(CaseFolderForEncoding()); + int pos = pdoc->FindText(ft->chrg.cpMin, ft->chrg.cpMax, ft->lpstrText, + (wParam & SCFIND_MATCHCASE) != 0, + (wParam & SCFIND_WHOLEWORD) != 0, + (wParam & SCFIND_WORDSTART) != 0, + (wParam & SCFIND_REGEXP) != 0, + wParam, + &lengthFound, + pcf.get()); + if (pos != -1) { + ft->chrgText.cpMin = pos; + ft->chrgText.cpMax = pos + lengthFound; + } + return pos; +} + +/** + * Relocatable search support : Searches relative to current selection + * point and sets the selection to the found text range with + * each search. + */ +/** + * Anchor following searches at current selection start: This allows + * multiple incremental interactive searches to be macro recorded + * while still setting the selection to found text so the find/select + * operation is self-contained. + */ +void Editor::SearchAnchor() { + searchAnchor = SelectionStart().Position(); +} + +/** + * Find text from current search anchor: Must call @c SearchAnchor first. + * Used for next text and previous text requests. + * @return The position of the found text, -1 if not found. + */ +long Editor::SearchText( + unsigned int iMessage, ///< Accepts both @c SCI_SEARCHNEXT and @c SCI_SEARCHPREV. + uptr_t wParam, ///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD, + ///< @c SCFIND_WORDSTART, @c SCFIND_REGEXP or @c SCFIND_POSIX. + sptr_t lParam) { ///< The text to search for. + + const char *txt = reinterpret_cast(lParam); + int pos; + int lengthFound = istrlen(txt); + std::auto_ptr pcf(CaseFolderForEncoding()); + if (iMessage == SCI_SEARCHNEXT) { + pos = pdoc->FindText(searchAnchor, pdoc->Length(), txt, + (wParam & SCFIND_MATCHCASE) != 0, + (wParam & SCFIND_WHOLEWORD) != 0, + (wParam & SCFIND_WORDSTART) != 0, + (wParam & SCFIND_REGEXP) != 0, + wParam, + &lengthFound, + pcf.get()); + } else { + pos = pdoc->FindText(searchAnchor, 0, txt, + (wParam & SCFIND_MATCHCASE) != 0, + (wParam & SCFIND_WHOLEWORD) != 0, + (wParam & SCFIND_WORDSTART) != 0, + (wParam & SCFIND_REGEXP) != 0, + wParam, + &lengthFound, + pcf.get()); + } + if (pos != -1) { + SetSelection(pos, pos + lengthFound); + } + + return pos; +} + +std::string Editor::CaseMapString(const std::string &s, int caseMapping) { + std::string ret(s); + for (size_t i=0; i= 'a' && ret[i] <= 'z') + ret[i] = static_cast(ret[i] - 'a' + 'A'); + break; + case cmLower: + if (ret[i] >= 'A' && ret[i] <= 'Z') + ret[i] = static_cast(ret[i] - 'A' + 'a'); + break; + } + } + return ret; +} + +/** + * Search for text in the target range of the document. + * @return The position of the found text, -1 if not found. + */ +long Editor::SearchInTarget(const char *text, int length) { + int lengthFound = length; + + std::auto_ptr pcf(CaseFolderForEncoding()); + int pos = pdoc->FindText(targetStart, targetEnd, text, + (searchFlags & SCFIND_MATCHCASE) != 0, + (searchFlags & SCFIND_WHOLEWORD) != 0, + (searchFlags & SCFIND_WORDSTART) != 0, + (searchFlags & SCFIND_REGEXP) != 0, + searchFlags, + &lengthFound, + pcf.get()); + if (pos != -1) { + targetStart = pos; + targetEnd = pos + lengthFound; + } + return pos; +} + +void Editor::GoToLine(int lineNo) { + if (lineNo > pdoc->LinesTotal()) + lineNo = pdoc->LinesTotal(); + if (lineNo < 0) + lineNo = 0; + SetEmptySelection(pdoc->LineStart(lineNo)); + ShowCaretAtCurrentPosition(); + EnsureCaretVisible(); +} + +static bool Close(Point pt1, Point pt2) { + if (abs(pt1.x - pt2.x) > 3) + return false; + if (abs(pt1.y - pt2.y) > 3) + return false; + return true; +} + +char *Editor::CopyRange(int start, int end) { + char *text = 0; + if (start < end) { + int len = end - start; + text = new char[len + 1]; + for (int i = 0; i < len; i++) { + text[i] = pdoc->CharAt(start + i); + } + text[len] = '\0'; + } + return text; +} + +void Editor::CopySelectionRange(SelectionText *ss, bool allowLineCopy) { + if (sel.Empty()) { + if (allowLineCopy) { + int currentLine = pdoc->LineFromPosition(sel.MainCaret()); + int start = pdoc->LineStart(currentLine); + int end = pdoc->LineEnd(currentLine); + + char *text = CopyRange(start, end); + int textLen = text ? strlen(text) : 0; + // include room for \r\n\0 + textLen += 3; + char *textWithEndl = new char[textLen]; + textWithEndl[0] = '\0'; + if (text) + strncat(textWithEndl, text, textLen); + if (pdoc->eolMode != SC_EOL_LF) + strncat(textWithEndl, "\r", textLen); + if (pdoc->eolMode != SC_EOL_CR) + strncat(textWithEndl, "\n", textLen); + ss->Set(textWithEndl, strlen(textWithEndl) + 1, + pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, true); + delete []text; + } + } else { + int delimiterLength = 0; + if (sel.selType == Selection::selRectangle) { + if (pdoc->eolMode == SC_EOL_CRLF) { + delimiterLength = 2; + } else { + delimiterLength = 1; + } + } + int size = sel.Length() + delimiterLength * sel.Count(); + char *text = new char[size + 1]; + int j = 0; + std::vector rangesInOrder = sel.RangesCopy(); + if (sel.selType == Selection::selRectangle) + std::sort(rangesInOrder.begin(), rangesInOrder.end()); + for (size_t r=0; rCharAt(i); + } + if (sel.selType == Selection::selRectangle) { + if (pdoc->eolMode != SC_EOL_LF) { + text[j++] = '\r'; + } + if (pdoc->eolMode != SC_EOL_CR) { + text[j++] = '\n'; + } + } + } + text[size] = '\0'; + ss->Set(text, size + 1, pdoc->dbcsCodePage, + vs.styles[STYLE_DEFAULT].characterSet, sel.IsRectangular(), sel.selType == Selection::selLines); + } +} + +void Editor::CopyRangeToClipboard(int start, int end) { + start = pdoc->ClampPositionIntoDocument(start); + end = pdoc->ClampPositionIntoDocument(end); + SelectionText selectedText; + selectedText.Set(CopyRange(start, end), end - start + 1, + pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, false); + CopyToClipboard(selectedText); +} + +void Editor::CopyText(int length, const char *text) { + SelectionText selectedText; + selectedText.Copy(text, length + 1, + pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, false); + CopyToClipboard(selectedText); +} + +void Editor::SetDragPosition(SelectionPosition newPos) { + if (newPos.Position() >= 0) { + newPos = MovePositionOutsideChar(newPos, 1); + posDrop = newPos; + } + if (!(posDrag == newPos)) { + caret.on = true; + SetTicking(true); + InvalidateCaret(); + posDrag = newPos; + InvalidateCaret(); + } +} + +void Editor::DisplayCursor(Window::Cursor c) { + if (cursorMode == SC_CURSORNORMAL) + wMain.SetCursor(c); + else + wMain.SetCursor(static_cast(cursorMode)); +} + +bool Editor::DragThreshold(Point ptStart, Point ptNow) { + int xMove = ptStart.x - ptNow.x; + int yMove = ptStart.y - ptNow.y; + int distanceSquared = xMove * xMove + yMove * yMove; + return distanceSquared > 16; +} + +void Editor::StartDrag() { + // Always handled by subclasses + //SetMouseCapture(true); + //DisplayCursor(Window::cursorArrow); +} + +void Editor::DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular) { + //Platform::DebugPrintf("DropAt %d %d\n", inDragDrop, position); + if (inDragDrop == ddDragging) + dropWentOutside = false; + + bool positionWasInSelection = PositionInSelection(position.Position()); + + bool positionOnEdgeOfSelection = + (position == SelectionStart()) || (position == SelectionEnd()); + + if ((inDragDrop != ddDragging) || !(positionWasInSelection) || + (positionOnEdgeOfSelection && !moving)) { + + SelectionPosition selStart = SelectionStart(); + SelectionPosition selEnd = SelectionEnd(); + + UndoGroup ug(pdoc); + + SelectionPosition positionAfterDeletion = position; + if ((inDragDrop == ddDragging) && moving) { + // Remove dragged out text + if (rectangular || sel.selType == Selection::selLines) { + for (size_t r=0; r= sel.Range(r).Start()) { + if (position > sel.Range(r).End()) { + positionAfterDeletion.Add(-sel.Range(r).Length()); + } else { + positionAfterDeletion.Add(-SelectionRange(position, sel.Range(r).Start()).Length()); + } + } + } + } else { + if (position > selStart) { + positionAfterDeletion.Add(-SelectionRange(selEnd, selStart).Length()); + } + } + ClearSelection(); + } + position = positionAfterDeletion; + + if (rectangular) { + PasteRectangular(position, value, istrlen(value)); + // Should try to select new rectangle but it may not be a rectangle now so just select the drop position + SetEmptySelection(position); + } else { + position = MovePositionOutsideChar(position, sel.MainCaret() - position.Position()); + position = SelectionPosition(InsertSpace(position.Position(), position.VirtualSpace())); + if (pdoc->InsertCString(position.Position(), value)) { + SelectionPosition posAfterInsertion = position; + posAfterInsertion.Add(istrlen(value)); + SetSelection(posAfterInsertion, position); + } + } + } else if (inDragDrop == ddDragging) { + SetEmptySelection(position); + } +} + +/** + * @return true if given position is inside the selection, + */ +bool Editor::PositionInSelection(int pos) { + pos = MovePositionOutsideChar(pos, sel.MainCaret() - pos); + for (size_t r=0; r xPos) { + hit = false; + } + } + if (hit) + return true; + } + } + return false; +} + +bool Editor::PointInSelMargin(Point pt) { + // Really means: "Point in a margin" + if (vs.fixedColumnWidth > 0) { // There is a margin + PRectangle rcSelMargin = GetClientRectangle(); + rcSelMargin.right = vs.fixedColumnWidth - vs.leftMarginWidth; + return rcSelMargin.Contains(pt); + } else { + return false; + } +} + +void Editor::LineSelection(int lineCurrent_, int lineAnchor_) { + if (lineAnchor_ < lineCurrent_) { + SetSelection(pdoc->LineStart(lineCurrent_ + 1), + pdoc->LineStart(lineAnchor_)); + } else if (lineAnchor_ > lineCurrent_) { + SetSelection(pdoc->LineStart(lineCurrent_), + pdoc->LineStart(lineAnchor_ + 1)); + } else { // Same line, select it + SetSelection(pdoc->LineStart(lineAnchor_ + 1), + pdoc->LineStart(lineAnchor_)); + } +} + +void Editor::DwellEnd(bool mouseMoved) { + if (mouseMoved) + ticksToDwell = dwellDelay; + else + ticksToDwell = SC_TIME_FOREVER; + if (dwelling && (dwellDelay < SC_TIME_FOREVER)) { + dwelling = false; + NotifyDwelling(ptMouseLast, dwelling); + } +} + +void Editor::MouseLeave() { + SetHotSpotRange(NULL); +} + +static bool AllowVirtualSpace(int virtualSpaceOptions, bool rectangular) { + return ((virtualSpaceOptions & SCVS_USERACCESSIBLE) != 0) + || (rectangular && ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) != 0)); +} + +void Editor::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) { + //Platform::DebugPrintf("ButtonDown %d %d = %d alt=%d %d\n", curTime, lastClickTime, curTime - lastClickTime, alt, inDragDrop); + ptMouseLast = pt; + SelectionPosition newPos = SPositionFromLocation(pt, false, false, AllowVirtualSpace(virtualSpaceOptions, alt)); + newPos = MovePositionOutsideChar(newPos, sel.MainCaret() - newPos.Position()); + inDragDrop = ddNone; + sel.SetMoveExtends(false); + + bool processed = NotifyMarginClick(pt, shift, ctrl, alt); + if (processed) + return; + + NotifyIndicatorClick(true, newPos.Position(), shift, ctrl, alt); + + bool inSelMargin = PointInSelMargin(pt); + if (shift & !inSelMargin) { + SetSelection(newPos.Position()); + } + if (((curTime - lastClickTime) < Platform::DoubleClickTime()) && Close(pt, lastClick)) { + //Platform::DebugPrintf("Double click %d %d = %d\n", curTime, lastClickTime, curTime - lastClickTime); + SetMouseCapture(true); + SetEmptySelection(newPos.Position()); + bool doubleClick = false; + // Stop mouse button bounce changing selection type + if (!Platform::MouseButtonBounce() || curTime != lastClickTime) { + if (selectionType == selChar) { + selectionType = selWord; + doubleClick = true; + } else if (selectionType == selWord) { + selectionType = selLine; + } else { + selectionType = selChar; + originalAnchorPos = sel.MainCaret(); + } + } + + if (selectionType == selWord) { + if (sel.MainCaret() >= originalAnchorPos) { // Moved forward + SetSelection(pdoc->ExtendWordSelect(sel.MainCaret(), 1), + pdoc->ExtendWordSelect(originalAnchorPos, -1)); + } else { // Moved backward + SetSelection(pdoc->ExtendWordSelect(sel.MainCaret(), -1), + pdoc->ExtendWordSelect(originalAnchorPos, 1)); + } + } else if (selectionType == selLine) { + lineAnchor = LineFromLocation(pt); + SetSelection(pdoc->LineStart(lineAnchor + 1), pdoc->LineStart(lineAnchor)); + //Platform::DebugPrintf("Triple click: %d - %d\n", anchor, currentPos); + } else { + SetEmptySelection(sel.MainCaret()); + } + //Platform::DebugPrintf("Double click: %d - %d\n", anchor, currentPos); + if (doubleClick) { + NotifyDoubleClick(pt, shift, ctrl, alt); + if (PositionIsHotspot(newPos.Position())) + NotifyHotSpotDoubleClicked(newPos.Position(), shift, ctrl, alt); + } + } else { // Single click + if (inSelMargin) { + sel.selType = Selection::selStream; + if (ctrl) { + SelectAll(); + lastClickTime = curTime; + return; + } + if (!shift) { + lineAnchor = LineFromLocation(pt); + // Single click in margin: select whole line + LineSelection(lineAnchor, lineAnchor); + SetSelection(pdoc->LineStart(lineAnchor + 1), + pdoc->LineStart(lineAnchor)); + } else { + // Single shift+click in margin: select from line anchor to clicked line + if (sel.MainAnchor() > sel.MainCaret()) + lineAnchor = pdoc->LineFromPosition(sel.MainAnchor() - 1); + else + lineAnchor = pdoc->LineFromPosition(sel.MainAnchor()); + int lineStart = LineFromLocation(pt); + LineSelection(lineStart, lineAnchor); + //lineAnchor = lineStart; // Keep the same anchor for ButtonMove + } + + SetDragPosition(SelectionPosition(invalidPosition)); + SetMouseCapture(true); + selectionType = selLine; + } else { + if (PointIsHotspot(pt)) { + NotifyHotSpotClicked(newPos.Position(), shift, ctrl, alt); + } + if (!shift) { + if (PointInSelection(pt) && !SelectionEmpty()) + inDragDrop = ddInitial; + else + inDragDrop = ddNone; + } + SetMouseCapture(true); + if (inDragDrop != ddInitial) { + SetDragPosition(SelectionPosition(invalidPosition)); + if (!shift) { + if (ctrl && multipleSelection) { + SelectionRange range(newPos); + sel.TentativeSelection(range); + InvalidateSelection(range, true); + } else { + InvalidateSelection(SelectionRange(newPos), true); + if (sel.Count() > 1) + Redraw(); + sel.Clear(); + sel.selType = alt ? Selection::selRectangle : Selection::selStream; + SetSelection(newPos, newPos); + } + } + SelectionPosition anchorCurrent = newPos; + if (shift) + anchorCurrent = sel.IsRectangular() ? + sel.Rectangular().anchor : sel.RangeMain().anchor; + sel.selType = alt ? Selection::selRectangle : Selection::selStream; + selectionType = selChar; + originalAnchorPos = sel.MainCaret(); + sel.Rectangular() = SelectionRange(newPos, anchorCurrent); + SetRectangularRange(); + } + } + } + lastClickTime = curTime; + lastXChosen = pt.x + xOffset; + ShowCaretAtCurrentPosition(); +} + +bool Editor::PositionIsHotspot(int position) { + return vs.styles[pdoc->StyleAt(position) & pdoc->stylingBitsMask].hotspot; +} + +bool Editor::PointIsHotspot(Point pt) { + int pos = PositionFromLocation(pt, true); + if (pos == INVALID_POSITION) + return false; + return PositionIsHotspot(pos); +} + +void Editor::SetHotSpotRange(Point *pt) { + if (pt) { + int pos = PositionFromLocation(*pt); + + // If we don't limit this to word characters then the + // range can encompass more than the run range and then + // the underline will not be drawn properly. + int hsStart_ = pdoc->ExtendStyleRange(pos, -1, vs.hotspotSingleLine); + int hsEnd_ = pdoc->ExtendStyleRange(pos, 1, vs.hotspotSingleLine); + + // Only invalidate the range if the hotspot range has changed... + if (hsStart_ != hsStart || hsEnd_ != hsEnd) { + if (hsStart != -1) { + InvalidateRange(hsStart, hsEnd); + } + hsStart = hsStart_; + hsEnd = hsEnd_; + InvalidateRange(hsStart, hsEnd); + } + } else { + if (hsStart != -1) { + int hsStart_ = hsStart; + int hsEnd_ = hsEnd; + hsStart = -1; + hsEnd = -1; + InvalidateRange(hsStart_, hsEnd_); + } else { + hsStart = -1; + hsEnd = -1; + } + } +} + +void Editor::GetHotSpotRange(int& hsStart_, int& hsEnd_) { + hsStart_ = hsStart; + hsEnd_ = hsEnd; +} + +void Editor::ButtonMove(Point pt) { + if ((ptMouseLast.x != pt.x) || (ptMouseLast.y != pt.y)) { + DwellEnd(true); + } + + SelectionPosition movePos = SPositionFromLocation(pt, false, false, + AllowVirtualSpace(virtualSpaceOptions, sel.IsRectangular())); + movePos = MovePositionOutsideChar(movePos, sel.MainCaret() - movePos.Position()); + + if (inDragDrop == ddInitial) { + if (DragThreshold(ptMouseLast, pt)) { + SetMouseCapture(false); + SetDragPosition(movePos); + CopySelectionRange(&drag); + StartDrag(); + } + return; + } + + ptMouseLast = pt; + //Platform::DebugPrintf("Move %d %d\n", pt.x, pt.y); + if (HaveMouseCapture()) { + + // Slow down autoscrolling/selection + autoScrollTimer.ticksToWait -= timer.tickSize; + if (autoScrollTimer.ticksToWait > 0) + return; + autoScrollTimer.ticksToWait = autoScrollDelay; + + // Adjust selection + if (posDrag.IsValid()) { + SetDragPosition(movePos); + } else { + if (selectionType == selChar) { + if (sel.IsRectangular()) { + sel.Rectangular() = SelectionRange(movePos, sel.Rectangular().anchor); + SetSelection(movePos, sel.RangeMain().anchor); + } else if (sel.Count() > 1) { + SelectionRange range(movePos, sel.RangeMain().anchor); + sel.TentativeSelection(range); + InvalidateSelection(range, true); + } else { + SetSelection(movePos, sel.RangeMain().anchor); + } + } else if (selectionType == selWord) { + // Continue selecting by word + if (movePos.Position() == originalAnchorPos) { // Didn't move + // No need to do anything. Previously this case was lumped + // in with "Moved forward", but that can be harmful in this + // case: a handler for the NotifyDoubleClick re-adjusts + // the selection for a fancier definition of "word" (for + // example, in Perl it is useful to include the leading + // '$', '%' or '@' on variables for word selection). In this + // the ButtonMove() called via Tick() for auto-scrolling + // could result in the fancier word selection adjustment + // being unmade. + } else if (movePos.Position() > originalAnchorPos) { // Moved forward + SetSelection(pdoc->ExtendWordSelect(movePos.Position(), 1), + pdoc->ExtendWordSelect(originalAnchorPos, -1)); + } else { // Moved backward + SetSelection(pdoc->ExtendWordSelect(movePos.Position(), -1), + pdoc->ExtendWordSelect(originalAnchorPos, 1)); + } + } else { + // Continue selecting by line + int lineMove = LineFromLocation(pt); + LineSelection(lineMove, lineAnchor); + } + } + + // Autoscroll + PRectangle rcClient = GetClientRectangle(); + if (pt.y > rcClient.bottom) { + int lineMove = cs.DisplayFromDoc(LineFromLocation(pt)); + if (lineMove < 0) { + lineMove = cs.DisplayFromDoc(pdoc->LinesTotal() - 1); + } + ScrollTo(lineMove - LinesOnScreen() + 1); + Redraw(); + } else if (pt.y < rcClient.top) { + int lineMove = cs.DisplayFromDoc(LineFromLocation(pt)); + ScrollTo(lineMove - 1); + Redraw(); + } + EnsureCaretVisible(false, false, true); + + if (hsStart != -1 && !PositionIsHotspot(movePos.Position())) + SetHotSpotRange(NULL); + + } else { + if (vs.fixedColumnWidth > 0) { // There is a margin + if (PointInSelMargin(pt)) { + DisplayCursor(Window::cursorReverseArrow); + SetHotSpotRange(NULL); + return; // No need to test for selection + } + } + // Display regular (drag) cursor over selection + if (PointInSelection(pt) && !SelectionEmpty()) { + DisplayCursor(Window::cursorArrow); + } else if (PointIsHotspot(pt)) { + DisplayCursor(Window::cursorHand); + SetHotSpotRange(&pt); + } else { + DisplayCursor(Window::cursorText); + SetHotSpotRange(NULL); + } + } +} + +void Editor::ButtonUp(Point pt, unsigned int curTime, bool ctrl) { + //Platform::DebugPrintf("ButtonUp %d %d\n", HaveMouseCapture(), inDragDrop); + SelectionPosition newPos = SPositionFromLocation(pt, false, false, + AllowVirtualSpace(virtualSpaceOptions, sel.IsRectangular())); + newPos = MovePositionOutsideChar(newPos, sel.MainCaret() - newPos.Position()); + if (inDragDrop == ddInitial) { + inDragDrop = ddNone; + SetEmptySelection(newPos.Position()); + } + if (HaveMouseCapture()) { + if (PointInSelMargin(pt)) { + DisplayCursor(Window::cursorReverseArrow); + } else { + DisplayCursor(Window::cursorText); + SetHotSpotRange(NULL); + } + ptMouseLast = pt; + SetMouseCapture(false); + NotifyIndicatorClick(false, newPos.Position(), false, false, false); + if (inDragDrop == ddDragging) { + SelectionPosition selStart = SelectionStart(); + SelectionPosition selEnd = SelectionEnd(); + if (selStart < selEnd) { + if (drag.len) { + if (ctrl) { + if (pdoc->InsertString(newPos.Position(), drag.s, drag.len)) { + SetSelection(newPos.Position(), newPos.Position() + drag.len); + } + } else if (newPos < selStart) { + pdoc->DeleteChars(selStart.Position(), drag.len); + if (pdoc->InsertString(newPos.Position(), drag.s, drag.len)) { + SetSelection(newPos.Position(), newPos.Position() + drag.len); + } + } else if (newPos > selEnd) { + pdoc->DeleteChars(selStart.Position(), drag.len); + newPos.Add(-drag.len); + if (pdoc->InsertString(newPos.Position(), drag.s, drag.len)) { + SetSelection(newPos.Position(), newPos.Position() + drag.len); + } + } else { + SetEmptySelection(newPos.Position()); + } + drag.Free(); + } + selectionType = selChar; + } + } else { + if (selectionType == selChar) { + if (sel.Count() > 1) { + sel.RangeMain() = + SelectionRange(newPos, sel.Range(sel.Count() - 1).anchor); + InvalidateSelection(sel.RangeMain(), true); + } else { + SetSelection(newPos, sel.RangeMain().anchor); + } + } + sel.CommitTentative(); + } + SetRectangularRange(); + lastClickTime = curTime; + lastClick = pt; + lastXChosen = pt.x + xOffset; + if (sel.selType == Selection::selStream) { + SetLastXChosen(); + } + inDragDrop = ddNone; + EnsureCaretVisible(false); + } +} + +// Called frequently to perform background UI including +// caret blinking and automatic scrolling. +void Editor::Tick() { + if (HaveMouseCapture()) { + // Auto scroll + ButtonMove(ptMouseLast); + } + if (caret.period > 0) { + timer.ticksToWait -= timer.tickSize; + if (timer.ticksToWait <= 0) { + caret.on = !caret.on; + timer.ticksToWait = caret.period; + if (caret.active) { + InvalidateCaret(); + } + } + } + if (horizontalScrollBarVisible && trackLineWidth && (lineWidthMaxSeen > scrollWidth)) { + scrollWidth = lineWidthMaxSeen; + SetScrollBars(); + } + if ((dwellDelay < SC_TIME_FOREVER) && + (ticksToDwell > 0) && + (!HaveMouseCapture())) { + ticksToDwell -= timer.tickSize; + if (ticksToDwell <= 0) { + dwelling = true; + NotifyDwelling(ptMouseLast, dwelling); + } + } +} + +bool Editor::Idle() { + + bool idleDone; + + bool wrappingDone = wrapState == eWrapNone; + + if (!wrappingDone) { + // Wrap lines during idle. + WrapLines(false, -1); + // No more wrapping + if (wrapStart == wrapEnd) + wrappingDone = true; + } + + // Add more idle things to do here, but make sure idleDone is + // set correctly before the function returns. returning + // false will stop calling this idle funtion until SetIdle() is + // called again. + + idleDone = wrappingDone; // && thatDone && theOtherThingDone... + + return !idleDone; +} + +void Editor::SetFocusState(bool focusState) { + hasFocus = focusState; + NotifyFocus(hasFocus); + if (hasFocus) { + ShowCaretAtCurrentPosition(); + } else { + CancelModes(); + DropCaret(); + } +} + +int Editor::PositionAfterArea(PRectangle rcArea) { + // The start of the document line after the display line after the area + // This often means that the line after a modification is restyled which helps + // detect multiline comment additions and heals single line comments + int lineAfter = topLine + (rcArea.bottom - 1) / vs.lineHeight + 1; + if (lineAfter < cs.LinesDisplayed()) + return pdoc->LineStart(cs.DocFromDisplay(lineAfter) + 1); + else + return pdoc->Length(); +} + +// Style to a position within the view. If this causes a change at end of last line then +// affects later lines so style all the viewed text. +void Editor::StyleToPositionInView(Position pos) { + int endWindow = PositionAfterArea(GetClientRectangle()); + if (pos > endWindow) + pos = endWindow; + int styleAtEnd = pdoc->StyleAt(pos-1); + pdoc->EnsureStyledTo(pos); + if ((endWindow > pos) && (styleAtEnd != pdoc->StyleAt(pos-1))) { + // Style at end of line changed so is multi-line change like starting a comment + // so require rest of window to be styled. + pdoc->EnsureStyledTo(endWindow); + } +} + +void Editor::IdleStyling() { + // Style the line after the modification as this allows modifications that change just the + // line of the modification to heal instead of propagating to the rest of the window. + StyleToPositionInView(pdoc->LineStart(pdoc->LineFromPosition(styleNeeded.upTo) + 2)); + + if (needUpdateUI) { + NotifyUpdateUI(); + needUpdateUI = false; + } + styleNeeded.Reset(); +} + +void Editor::QueueStyling(int upTo) { + styleNeeded.NeedUpTo(upTo); +} + +bool Editor::PaintContains(PRectangle rc) { + if (rc.Empty()) { + return true; + } else { + return rcPaint.Contains(rc); + } +} + +bool Editor::PaintContainsMargin() { + PRectangle rcSelMargin = GetClientRectangle(); + rcSelMargin.right = vs.fixedColumnWidth; + return PaintContains(rcSelMargin); +} + +void Editor::CheckForChangeOutsidePaint(Range r) { + if (paintState == painting && !paintingAllText) { + //Platform::DebugPrintf("Checking range in paint %d-%d\n", r.start, r.end); + if (!r.Valid()) + return; + + PRectangle rcRange = RectangleFromRange(r.start, r.end); + PRectangle rcText = GetTextRectangle(); + if (rcRange.top < rcText.top) { + rcRange.top = rcText.top; + } + if (rcRange.bottom > rcText.bottom) { + rcRange.bottom = rcText.bottom; + } + + if (!PaintContains(rcRange)) { + AbandonPaint(); + } + } +} + +void Editor::SetBraceHighlight(Position pos0, Position pos1, int matchStyle) { + if ((pos0 != braces[0]) || (pos1 != braces[1]) || (matchStyle != bracesMatchStyle)) { + if ((braces[0] != pos0) || (matchStyle != bracesMatchStyle)) { + CheckForChangeOutsidePaint(Range(braces[0])); + CheckForChangeOutsidePaint(Range(pos0)); + braces[0] = pos0; + } + if ((braces[1] != pos1) || (matchStyle != bracesMatchStyle)) { + CheckForChangeOutsidePaint(Range(braces[1])); + CheckForChangeOutsidePaint(Range(pos1)); + braces[1] = pos1; + } + bracesMatchStyle = matchStyle; + if (paintState == notPainting) { + Redraw(); + } + } +} + +void Editor::SetAnnotationHeights(int start, int end) { + if (vs.annotationVisible) { + for (int line=start; lineAnnotationLines(line) + 1); + } + } +} + +void Editor::SetDocPointer(Document *document) { + //Platform::DebugPrintf("** %x setdoc to %x\n", pdoc, document); + pdoc->RemoveWatcher(this, 0); + pdoc->Release(); + if (document == NULL) { + pdoc = new Document(); + } else { + pdoc = document; + } + pdoc->AddRef(); + + // Ensure all positions within document + sel.Clear(); + targetStart = 0; + targetEnd = 0; + + braces[0] = invalidPosition; + braces[1] = invalidPosition; + + // Reset the contraction state to fully shown. + cs.Clear(); + cs.InsertLines(0, pdoc->LinesTotal() - 1); + SetAnnotationHeights(0, pdoc->LinesTotal()); + llc.Deallocate(); + NeedWrapping(); + + pdoc->AddWatcher(this, 0); + SetScrollBars(); + Redraw(); +} + +void Editor::SetAnnotationVisible(int visible) { + if (vs.annotationVisible != visible) { + bool changedFromOrToHidden = ((vs.annotationVisible != 0) != (visible != 0)); + vs.annotationVisible = visible; + if (changedFromOrToHidden) { + int dir = vs.annotationVisible ? 1 : -1; + for (int line=0; lineLinesTotal(); line++) { + int annotationLines = pdoc->AnnotationLines(line); + if (annotationLines > 0) { + cs.SetHeight(line, cs.GetHeight(line) + annotationLines * dir); + } + } + } + } +} + +/** + * Recursively expand a fold, making lines visible except where they have an unexpanded parent. + */ +void Editor::Expand(int &line, bool doExpand) { + int lineMaxSubord = pdoc->GetLastChild(line); + line++; + while (line <= lineMaxSubord) { + if (doExpand) + cs.SetVisible(line, line, true); + int level = pdoc->GetLevel(line); + if (level & SC_FOLDLEVELHEADERFLAG) { + if (doExpand && cs.GetExpanded(line)) { + Expand(line, true); + } else { + Expand(line, false); + } + } else { + line++; + } + } +} + +void Editor::ToggleContraction(int line) { + if (line >= 0) { + if ((pdoc->GetLevel(line) & SC_FOLDLEVELHEADERFLAG) == 0) { + line = pdoc->GetFoldParent(line); + if (line < 0) + return; + } + + if (cs.GetExpanded(line)) { + int lineMaxSubord = pdoc->GetLastChild(line); + cs.SetExpanded(line, 0); + if (lineMaxSubord > line) { + cs.SetVisible(line + 1, lineMaxSubord, false); + + int lineCurrent = pdoc->LineFromPosition(sel.MainCaret()); + if (lineCurrent > line && lineCurrent <= lineMaxSubord) { + // This does not re-expand the fold + EnsureCaretVisible(); + } + + SetScrollBars(); + Redraw(); + } + + } else { + if (!(cs.GetVisible(line))) { + EnsureLineVisible(line, false); + GoToLine(line); + } + cs.SetExpanded(line, 1); + Expand(line, true); + SetScrollBars(); + Redraw(); + } + } +} + +/** + * Recurse up from this line to find any folds that prevent this line from being visible + * and unfold them all. + */ +void Editor::EnsureLineVisible(int lineDoc, bool enforcePolicy) { + + // In case in need of wrapping to ensure DisplayFromDoc works. + WrapLines(true, -1); + + if (!cs.GetVisible(lineDoc)) { + int lineParent = pdoc->GetFoldParent(lineDoc); + if (lineParent >= 0) { + if (lineDoc != lineParent) + EnsureLineVisible(lineParent, enforcePolicy); + if (!cs.GetExpanded(lineParent)) { + cs.SetExpanded(lineParent, 1); + Expand(lineParent, true); + } + } + SetScrollBars(); + Redraw(); + } + if (enforcePolicy) { + int lineDisplay = cs.DisplayFromDoc(lineDoc); + if (visiblePolicy & VISIBLE_SLOP) { + if ((topLine > lineDisplay) || ((visiblePolicy & VISIBLE_STRICT) && (topLine + visibleSlop > lineDisplay))) { + SetTopLine(Platform::Clamp(lineDisplay - visibleSlop, 0, MaxScrollPos())); + SetVerticalScrollPos(); + Redraw(); + } else if ((lineDisplay > topLine + LinesOnScreen() - 1) || + ((visiblePolicy & VISIBLE_STRICT) && (lineDisplay > topLine + LinesOnScreen() - 1 - visibleSlop))) { + SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() + 1 + visibleSlop, 0, MaxScrollPos())); + SetVerticalScrollPos(); + Redraw(); + } + } else { + if ((topLine > lineDisplay) || (lineDisplay > topLine + LinesOnScreen() - 1) || (visiblePolicy & VISIBLE_STRICT)) { + SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() / 2 + 1, 0, MaxScrollPos())); + SetVerticalScrollPos(); + Redraw(); + } + } + } +} + +int Editor::GetTag(char *tagValue, int tagNumber) { + char name[3] = "\\?"; + const char *text = 0; + int length = 0; + if ((tagNumber >= 1) && (tagNumber <= 9)) { + name[1] = static_cast(tagNumber + '0'); + length = 2; + text = pdoc->SubstituteByPosition(name, &length); + } + if (tagValue) { + if (text) + memcpy(tagValue, text, length + 1); + else + *tagValue = '\0'; + } + return length; +} + +int Editor::ReplaceTarget(bool replacePatterns, const char *text, int length) { + UndoGroup ug(pdoc); + if (length == -1) + length = istrlen(text); + if (replacePatterns) { + text = pdoc->SubstituteByPosition(text, &length); + if (!text) { + return 0; + } + } + if (targetStart != targetEnd) + pdoc->DeleteChars(targetStart, targetEnd - targetStart); + targetEnd = targetStart; + pdoc->InsertString(targetStart, text, length); + targetEnd = targetStart + length; + return length; +} + +bool Editor::IsUnicodeMode() const { + return pdoc && (SC_CP_UTF8 == pdoc->dbcsCodePage); +} + +int Editor::CodePage() const { + if (pdoc) + return pdoc->dbcsCodePage; + else + return 0; +} + +int Editor::WrapCount(int line) { + AutoSurface surface(this); + AutoLineLayout ll(llc, RetrieveLineLayout(line)); + + if (surface && ll) { + LayoutLine(line, surface, vs, ll, wrapWidth); + return ll->lines; + } else { + return 1; + } +} + +void Editor::AddStyledText(char *buffer, int appendLength) { + // The buffer consists of alternating character bytes and style bytes + size_t textLength = appendLength / 2; + char *text = new char[textLength]; + size_t i; + for (i = 0;i < textLength;i++) { + text[i] = buffer[i*2]; + } + pdoc->InsertString(CurrentPosition(), text, textLength); + for (i = 0;i < textLength;i++) { + text[i] = buffer[i*2+1]; + } + pdoc->StartStyling(CurrentPosition(), static_cast(0xff)); + pdoc->SetStyles(textLength, text); + delete []text; + SetEmptySelection(sel.MainCaret() + textLength); +} + +static bool ValidMargin(unsigned long wParam) { + return wParam < ViewStyle::margins; +} + +static char *CharPtrFromSPtr(sptr_t lParam) { + return reinterpret_cast(lParam); +} + +void Editor::StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) { + vs.EnsureStyle(wParam); + switch (iMessage) { + case SCI_STYLESETFORE: + vs.styles[wParam].fore.desired = ColourDesired(lParam); + break; + case SCI_STYLESETBACK: + vs.styles[wParam].back.desired = ColourDesired(lParam); + break; + case SCI_STYLESETBOLD: + vs.styles[wParam].bold = lParam != 0; + break; + case SCI_STYLESETITALIC: + vs.styles[wParam].italic = lParam != 0; + break; + case SCI_STYLESETEOLFILLED: + vs.styles[wParam].eolFilled = lParam != 0; + break; + case SCI_STYLESETSIZE: + vs.styles[wParam].size = lParam; + break; + case SCI_STYLESETFONT: + if (lParam != 0) { + vs.SetStyleFontName(wParam, CharPtrFromSPtr(lParam)); + } + break; + case SCI_STYLESETUNDERLINE: + vs.styles[wParam].underline = lParam != 0; + break; + case SCI_STYLESETCASE: + vs.styles[wParam].caseForce = static_cast(lParam); + break; + case SCI_STYLESETCHARACTERSET: + vs.styles[wParam].characterSet = lParam; + break; + case SCI_STYLESETVISIBLE: + vs.styles[wParam].visible = lParam != 0; + break; + case SCI_STYLESETCHANGEABLE: + vs.styles[wParam].changeable = lParam != 0; + break; + case SCI_STYLESETHOTSPOT: + vs.styles[wParam].hotspot = lParam != 0; + break; + } + InvalidateStyleRedraw(); +} + +sptr_t Editor::StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) { + vs.EnsureStyle(wParam); + switch (iMessage) { + case SCI_STYLEGETFORE: + return vs.styles[wParam].fore.desired.AsLong(); + case SCI_STYLEGETBACK: + return vs.styles[wParam].back.desired.AsLong(); + case SCI_STYLEGETBOLD: + return vs.styles[wParam].bold ? 1 : 0; + case SCI_STYLEGETITALIC: + return vs.styles[wParam].italic ? 1 : 0; + case SCI_STYLEGETEOLFILLED: + return vs.styles[wParam].eolFilled ? 1 : 0; + case SCI_STYLEGETSIZE: + return vs.styles[wParam].size; + case SCI_STYLEGETFONT: + if (!vs.styles[wParam].fontName) + return 0; + if (lParam != 0) + strcpy(CharPtrFromSPtr(lParam), vs.styles[wParam].fontName); + return strlen(vs.styles[wParam].fontName); + case SCI_STYLEGETUNDERLINE: + return vs.styles[wParam].underline ? 1 : 0; + case SCI_STYLEGETCASE: + return static_cast(vs.styles[wParam].caseForce); + case SCI_STYLEGETCHARACTERSET: + return vs.styles[wParam].characterSet; + case SCI_STYLEGETVISIBLE: + return vs.styles[wParam].visible ? 1 : 0; + case SCI_STYLEGETCHANGEABLE: + return vs.styles[wParam].changeable ? 1 : 0; + case SCI_STYLEGETHOTSPOT: + return vs.styles[wParam].hotspot ? 1 : 0; + } + return 0; +} + +sptr_t Editor::StringResult(sptr_t lParam, const char *val) { + const int n = strlen(val); + if (lParam != 0) { + char *ptr = reinterpret_cast(lParam); + strcpy(ptr, val); + } + return n; // Not including NUL +} + +sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) { + //Platform::DebugPrintf("S start wnd proc %d %d %d\n",iMessage, wParam, lParam); + + // Optional macro recording hook + if (recordingMacro) + NotifyMacroRecord(iMessage, wParam, lParam); + + switch (iMessage) { + + case SCI_GETTEXT: { + if (lParam == 0) + return pdoc->Length() + 1; + if (wParam == 0) + return 0; + char *ptr = CharPtrFromSPtr(lParam); + unsigned int iChar = 0; + for (; iChar < wParam - 1; iChar++) + ptr[iChar] = pdoc->CharAt(iChar); + ptr[iChar] = '\0'; + return iChar; + } + + case SCI_SETTEXT: { + if (lParam == 0) + return 0; + UndoGroup ug(pdoc); + pdoc->DeleteChars(0, pdoc->Length()); + SetEmptySelection(0); + pdoc->InsertCString(0, CharPtrFromSPtr(lParam)); + return 1; + } + + case SCI_GETTEXTLENGTH: + return pdoc->Length(); + + case SCI_CUT: + Cut(); + SetLastXChosen(); + break; + + case SCI_COPY: + Copy(); + break; + + case SCI_COPYALLOWLINE: + CopyAllowLine(); + break; + + case SCI_COPYRANGE: + CopyRangeToClipboard(wParam, lParam); + break; + + case SCI_COPYTEXT: + CopyText(wParam, CharPtrFromSPtr(lParam)); + break; + + case SCI_PASTE: + Paste(); + if (!caretSticky) { + SetLastXChosen(); + } + EnsureCaretVisible(); + break; + + case SCI_CLEAR: + Clear(); + SetLastXChosen(); + EnsureCaretVisible(); + break; + + case SCI_UNDO: + Undo(); + SetLastXChosen(); + break; + + case SCI_CANUNDO: + return (pdoc->CanUndo() && !pdoc->IsReadOnly()) ? 1 : 0; + + case SCI_EMPTYUNDOBUFFER: + pdoc->DeleteUndoHistory(); + return 0; + + case SCI_GETFIRSTVISIBLELINE: + return topLine; + + case SCI_SETFIRSTVISIBLELINE: + ScrollTo(wParam); + break; + + case SCI_GETLINE: { // Risk of overwriting the end of the buffer + int lineStart = pdoc->LineStart(wParam); + int lineEnd = pdoc->LineStart(wParam + 1); + if (lParam == 0) { + return lineEnd - lineStart; + } + char *ptr = CharPtrFromSPtr(lParam); + int iPlace = 0; + for (int iChar = lineStart; iChar < lineEnd; iChar++) { + ptr[iPlace++] = pdoc->CharAt(iChar); + } + return iPlace; + } + + case SCI_GETLINECOUNT: + if (pdoc->LinesTotal() == 0) + return 1; + else + return pdoc->LinesTotal(); + + case SCI_GETMODIFY: + return !pdoc->IsSavePoint(); + + case SCI_SETSEL: { + int nStart = static_cast(wParam); + int nEnd = static_cast(lParam); + if (nEnd < 0) + nEnd = pdoc->Length(); + if (nStart < 0) + nStart = nEnd; // Remove selection + InvalidateSelection(SelectionRange(nStart, nEnd)); + sel.Clear(); + sel.selType = Selection::selStream; + SetSelection(nEnd, nStart); + EnsureCaretVisible(); + } + break; + + case SCI_GETSELTEXT: { + SelectionText selectedText; + CopySelectionRange(&selectedText); + if (lParam == 0) { + return selectedText.len ? selectedText.len : 1; + } else { + char *ptr = CharPtrFromSPtr(lParam); + int iChar = 0; + if (selectedText.len) { + for (; iChar < selectedText.len; iChar++) + ptr[iChar] = selectedText.s[iChar]; + } else { + ptr[0] = '\0'; + } + return iChar; + } + } + + case SCI_LINEFROMPOSITION: + if (static_cast(wParam) < 0) + return 0; + return pdoc->LineFromPosition(wParam); + + case SCI_POSITIONFROMLINE: + if (static_cast(wParam) < 0) + wParam = pdoc->LineFromPosition(SelectionStart().Position()); + if (wParam == 0) + return 0; // Even if there is no text, there is a first line that starts at 0 + if (static_cast(wParam) > pdoc->LinesTotal()) + return -1; + //if (wParam > pdoc->LineFromPosition(pdoc->Length())) // Useful test, anyway... + // return -1; + return pdoc->LineStart(wParam); + + // Replacement of the old Scintilla interpretation of EM_LINELENGTH + case SCI_LINELENGTH: + if ((static_cast(wParam) < 0) || + (static_cast(wParam) > pdoc->LineFromPosition(pdoc->Length()))) + return 0; + return pdoc->LineStart(wParam + 1) - pdoc->LineStart(wParam); + + case SCI_REPLACESEL: { + if (lParam == 0) + return 0; + UndoGroup ug(pdoc); + ClearSelection(); + char *replacement = CharPtrFromSPtr(lParam); + pdoc->InsertCString(sel.MainCaret(), replacement); + SetEmptySelection(sel.MainCaret() + istrlen(replacement)); + EnsureCaretVisible(); + } + break; + + case SCI_SETTARGETSTART: + targetStart = wParam; + break; + + case SCI_GETTARGETSTART: + return targetStart; + + case SCI_SETTARGETEND: + targetEnd = wParam; + break; + + case SCI_GETTARGETEND: + return targetEnd; + + case SCI_TARGETFROMSELECTION: + if (sel.MainCaret() < sel.MainAnchor()) { + targetStart = sel.MainCaret(); + targetEnd = sel.MainAnchor(); + } else { + targetStart = sel.MainAnchor(); + targetEnd = sel.MainCaret(); + } + break; + + case SCI_REPLACETARGET: + PLATFORM_ASSERT(lParam); + return ReplaceTarget(false, CharPtrFromSPtr(lParam), wParam); + + case SCI_REPLACETARGETRE: + PLATFORM_ASSERT(lParam); + return ReplaceTarget(true, CharPtrFromSPtr(lParam), wParam); + + case SCI_SEARCHINTARGET: + PLATFORM_ASSERT(lParam); + return SearchInTarget(CharPtrFromSPtr(lParam), wParam); + + case SCI_SETSEARCHFLAGS: + searchFlags = wParam; + break; + + case SCI_GETSEARCHFLAGS: + return searchFlags; + + case SCI_GETTAG: + return GetTag(CharPtrFromSPtr(lParam), wParam); + + case SCI_POSITIONBEFORE: + return pdoc->MovePositionOutsideChar(wParam - 1, -1, true); + + case SCI_POSITIONAFTER: + return pdoc->MovePositionOutsideChar(wParam + 1, 1, true); + + case SCI_LINESCROLL: + ScrollTo(topLine + lParam); + HorizontalScrollTo(xOffset + wParam * vs.spaceWidth); + return 1; + + case SCI_SETXOFFSET: + xOffset = wParam; + SetHorizontalScrollPos(); + Redraw(); + break; + + case SCI_GETXOFFSET: + return xOffset; + + case SCI_CHOOSECARETX: + SetLastXChosen(); + break; + + case SCI_SCROLLCARET: + EnsureCaretVisible(); + break; + + case SCI_SETREADONLY: + pdoc->SetReadOnly(wParam != 0); + return 1; + + case SCI_GETREADONLY: + return pdoc->IsReadOnly(); + + case SCI_CANPASTE: + return CanPaste(); + + case SCI_POINTXFROMPOSITION: + if (lParam < 0) { + return 0; + } else { + Point pt = LocationFromPosition(lParam); + return pt.x; + } + + case SCI_POINTYFROMPOSITION: + if (lParam < 0) { + return 0; + } else { + Point pt = LocationFromPosition(lParam); + return pt.y; + } + + case SCI_FINDTEXT: + return FindText(wParam, lParam); + + case SCI_GETTEXTRANGE: { + if (lParam == 0) + return 0; + Sci_TextRange *tr = reinterpret_cast(lParam); + int cpMax = tr->chrg.cpMax; + if (cpMax == -1) + cpMax = pdoc->Length(); + PLATFORM_ASSERT(cpMax <= pdoc->Length()); + int len = cpMax - tr->chrg.cpMin; // No -1 as cpMin and cpMax are referring to inter character positions + pdoc->GetCharRange(tr->lpstrText, tr->chrg.cpMin, len); + // Spec says copied text is terminated with a NUL + tr->lpstrText[len] = '\0'; + return len; // Not including NUL + } + + case SCI_HIDESELECTION: + hideSelection = wParam != 0; + Redraw(); + break; + + case SCI_FORMATRANGE: + return FormatRange(wParam != 0, reinterpret_cast(lParam)); + + case SCI_GETMARGINLEFT: + return vs.leftMarginWidth; + + case SCI_GETMARGINRIGHT: + return vs.rightMarginWidth; + + case SCI_SETMARGINLEFT: + vs.leftMarginWidth = lParam; + InvalidateStyleRedraw(); + break; + + case SCI_SETMARGINRIGHT: + vs.rightMarginWidth = lParam; + InvalidateStyleRedraw(); + break; + + // Control specific mesages + + case SCI_ADDTEXT: { + if (lParam == 0) + return 0; + pdoc->InsertString(CurrentPosition(), CharPtrFromSPtr(lParam), wParam); + SetEmptySelection(sel.MainCaret() + wParam); + return 0; + } + + case SCI_ADDSTYLEDTEXT: + if (lParam) + AddStyledText(CharPtrFromSPtr(lParam), wParam); + return 0; + + case SCI_INSERTTEXT: { + if (lParam == 0) + return 0; + int insertPos = wParam; + if (static_cast(wParam) == -1) + insertPos = CurrentPosition(); + int newCurrent = CurrentPosition(); + char *sz = CharPtrFromSPtr(lParam); + pdoc->InsertCString(insertPos, sz); + if (newCurrent > insertPos) + newCurrent += istrlen(sz); + SetEmptySelection(newCurrent); + return 0; + } + + case SCI_APPENDTEXT: + pdoc->InsertString(pdoc->Length(), CharPtrFromSPtr(lParam), wParam); + return 0; + + case SCI_CLEARALL: + ClearAll(); + return 0; + + case SCI_CLEARDOCUMENTSTYLE: + ClearDocumentStyle(); + return 0; + + case SCI_SETUNDOCOLLECTION: + pdoc->SetUndoCollection(wParam != 0); + return 0; + + case SCI_GETUNDOCOLLECTION: + return pdoc->IsCollectingUndo(); + + case SCI_BEGINUNDOACTION: + pdoc->BeginUndoAction(); + return 0; + + case SCI_ENDUNDOACTION: + pdoc->EndUndoAction(); + return 0; + + case SCI_GETCARETPERIOD: + return caret.period; + + case SCI_SETCARETPERIOD: + caret.period = wParam; + break; + + case SCI_SETWORDCHARS: { + pdoc->SetDefaultCharClasses(false); + if (lParam == 0) + return 0; + pdoc->SetCharClasses(reinterpret_cast(lParam), CharClassify::ccWord); + } + break; + + case SCI_SETWHITESPACECHARS: { + if (lParam == 0) + return 0; + pdoc->SetCharClasses(reinterpret_cast(lParam), CharClassify::ccSpace); + } + break; + + case SCI_SETCHARSDEFAULT: + pdoc->SetDefaultCharClasses(true); + break; + + case SCI_GETLENGTH: + return pdoc->Length(); + + case SCI_ALLOCATE: + pdoc->Allocate(wParam); + break; + + case SCI_GETCHARAT: + return pdoc->CharAt(wParam); + + case SCI_SETCURRENTPOS: + if (sel.IsRectangular()) { + sel.Rectangular().caret.SetPosition(wParam); + SetRectangularRange(); + Redraw(); + } else { + SetSelection(wParam, sel.MainAnchor()); + } + break; + + case SCI_GETCURRENTPOS: + return sel.IsRectangular() ? sel.Rectangular().caret.Position() : sel.MainCaret(); + + case SCI_SETANCHOR: + if (sel.IsRectangular()) { + sel.Rectangular().anchor.SetPosition(wParam); + SetRectangularRange(); + Redraw(); + } else { + SetSelection(sel.MainCaret(), wParam); + } + break; + + case SCI_GETANCHOR: + return sel.IsRectangular() ? sel.Rectangular().anchor.Position() : sel.MainAnchor(); + + case SCI_SETSELECTIONSTART: + SetSelection(Platform::Maximum(sel.MainCaret(), wParam), wParam); + break; + + case SCI_GETSELECTIONSTART: + return sel.LimitsForRectangularElseMain().start.Position(); + + case SCI_SETSELECTIONEND: + SetSelection(wParam, Platform::Minimum(sel.MainAnchor(), wParam)); + break; + + case SCI_GETSELECTIONEND: + return sel.LimitsForRectangularElseMain().end.Position(); + + case SCI_SETPRINTMAGNIFICATION: + printMagnification = wParam; + break; + + case SCI_GETPRINTMAGNIFICATION: + return printMagnification; + + case SCI_SETPRINTCOLOURMODE: + printColourMode = wParam; + break; + + case SCI_GETPRINTCOLOURMODE: + return printColourMode; + + case SCI_SETPRINTWRAPMODE: + printWrapState = (wParam == SC_WRAP_WORD) ? eWrapWord : eWrapNone; + break; + + case SCI_GETPRINTWRAPMODE: + return printWrapState; + + case SCI_GETSTYLEAT: + if (static_cast(wParam) >= pdoc->Length()) + return 0; + else + return pdoc->StyleAt(wParam); + + case SCI_REDO: + Redo(); + break; + + case SCI_SELECTALL: + SelectAll(); + break; + + case SCI_SETSAVEPOINT: + pdoc->SetSavePoint(); + break; + + case SCI_GETSTYLEDTEXT: { + if (lParam == 0) + return 0; + Sci_TextRange *tr = reinterpret_cast(lParam); + int iPlace = 0; + for (int iChar = tr->chrg.cpMin; iChar < tr->chrg.cpMax; iChar++) { + tr->lpstrText[iPlace++] = pdoc->CharAt(iChar); + tr->lpstrText[iPlace++] = pdoc->StyleAt(iChar); + } + tr->lpstrText[iPlace] = '\0'; + tr->lpstrText[iPlace + 1] = '\0'; + return iPlace; + } + + case SCI_CANREDO: + return (pdoc->CanRedo() && !pdoc->IsReadOnly()) ? 1 : 0; + + case SCI_MARKERLINEFROMHANDLE: + return pdoc->LineFromHandle(wParam); + + case SCI_MARKERDELETEHANDLE: + pdoc->DeleteMarkFromHandle(wParam); + break; + + case SCI_GETVIEWWS: + return vs.viewWhitespace; + + case SCI_SETVIEWWS: + vs.viewWhitespace = static_cast(wParam); + Redraw(); + break; + + case SCI_GETWHITESPACESIZE: + return vs.whitespaceSize; + + case SCI_SETWHITESPACESIZE: + vs.whitespaceSize = static_cast(wParam); + Redraw(); + break; + + case SCI_POSITIONFROMPOINT: + return PositionFromLocation(Point(wParam, lParam), false, false); + + case SCI_POSITIONFROMPOINTCLOSE: + return PositionFromLocation(Point(wParam, lParam), true, false); + + case SCI_CHARPOSITIONFROMPOINT: + return PositionFromLocation(Point(wParam, lParam), false, true); + + case SCI_CHARPOSITIONFROMPOINTCLOSE: + return PositionFromLocation(Point(wParam, lParam), true, true); + + case SCI_GOTOLINE: + GoToLine(wParam); + break; + + case SCI_GOTOPOS: + SetEmptySelection(wParam); + EnsureCaretVisible(); + Redraw(); + break; + + case SCI_GETCURLINE: { + int lineCurrentPos = pdoc->LineFromPosition(sel.MainCaret()); + int lineStart = pdoc->LineStart(lineCurrentPos); + unsigned int lineEnd = pdoc->LineStart(lineCurrentPos + 1); + if (lParam == 0) { + return 1 + lineEnd - lineStart; + } + PLATFORM_ASSERT(wParam > 0); + char *ptr = CharPtrFromSPtr(lParam); + unsigned int iPlace = 0; + for (unsigned int iChar = lineStart; iChar < lineEnd && iPlace < wParam - 1; iChar++) { + ptr[iPlace++] = pdoc->CharAt(iChar); + } + ptr[iPlace] = '\0'; + return sel.MainCaret() - lineStart; + } + + case SCI_GETENDSTYLED: + return pdoc->GetEndStyled(); + + case SCI_GETEOLMODE: + return pdoc->eolMode; + + case SCI_SETEOLMODE: + pdoc->eolMode = wParam; + break; + + case SCI_STARTSTYLING: + pdoc->StartStyling(wParam, static_cast(lParam)); + break; + + case SCI_SETSTYLING: + pdoc->SetStyleFor(wParam, static_cast(lParam)); + break; + + case SCI_SETSTYLINGEX: // Specify a complete styling buffer + if (lParam == 0) + return 0; + pdoc->SetStyles(wParam, CharPtrFromSPtr(lParam)); + break; + + case SCI_SETBUFFEREDDRAW: + bufferedDraw = wParam != 0; + break; + + case SCI_GETBUFFEREDDRAW: + return bufferedDraw; + + case SCI_GETTWOPHASEDRAW: + return twoPhaseDraw; + + case SCI_SETTWOPHASEDRAW: + twoPhaseDraw = wParam != 0; + InvalidateStyleRedraw(); + break; + + case SCI_SETFONTQUALITY: + vs.extraFontFlag &= ~SC_EFF_QUALITY_MASK; + vs.extraFontFlag |= (wParam & SC_EFF_QUALITY_MASK); + InvalidateStyleRedraw(); + break; + + case SCI_GETFONTQUALITY: + return (vs.extraFontFlag & SC_EFF_QUALITY_MASK); + + case SCI_SETTABWIDTH: + if (wParam > 0) { + pdoc->tabInChars = wParam; + if (pdoc->indentInChars == 0) + pdoc->actualIndentInChars = pdoc->tabInChars; + } + InvalidateStyleRedraw(); + break; + + case SCI_GETTABWIDTH: + return pdoc->tabInChars; + + case SCI_SETINDENT: + pdoc->indentInChars = wParam; + if (pdoc->indentInChars != 0) + pdoc->actualIndentInChars = pdoc->indentInChars; + else + pdoc->actualIndentInChars = pdoc->tabInChars; + InvalidateStyleRedraw(); + break; + + case SCI_GETINDENT: + return pdoc->indentInChars; + + case SCI_SETUSETABS: + pdoc->useTabs = wParam != 0; + InvalidateStyleRedraw(); + break; + + case SCI_GETUSETABS: + return pdoc->useTabs; + + case SCI_SETLINEINDENTATION: + pdoc->SetLineIndentation(wParam, lParam); + break; + + case SCI_GETLINEINDENTATION: + return pdoc->GetLineIndentation(wParam); + + case SCI_GETLINEINDENTPOSITION: + return pdoc->GetLineIndentPosition(wParam); + + case SCI_SETTABINDENTS: + pdoc->tabIndents = wParam != 0; + break; + + case SCI_GETTABINDENTS: + return pdoc->tabIndents; + + case SCI_SETBACKSPACEUNINDENTS: + pdoc->backspaceUnindents = wParam != 0; + break; + + case SCI_GETBACKSPACEUNINDENTS: + return pdoc->backspaceUnindents; + + case SCI_SETMOUSEDWELLTIME: + dwellDelay = wParam; + ticksToDwell = dwellDelay; + break; + + case SCI_GETMOUSEDWELLTIME: + return dwellDelay; + + case SCI_WORDSTARTPOSITION: + return pdoc->ExtendWordSelect(wParam, -1, lParam != 0); + + case SCI_WORDENDPOSITION: + return pdoc->ExtendWordSelect(wParam, 1, lParam != 0); + + case SCI_SETWRAPMODE: + switch (wParam) { + case SC_WRAP_WORD: + wrapState = eWrapWord; + break; + case SC_WRAP_CHAR: + wrapState = eWrapChar; + break; + default: + wrapState = eWrapNone; + break; + } + xOffset = 0; + InvalidateStyleRedraw(); + ReconfigureScrollBars(); + break; + + case SCI_GETWRAPMODE: + return wrapState; + + case SCI_SETWRAPVISUALFLAGS: + if (wrapVisualFlags != static_cast(wParam)) { + wrapVisualFlags = wParam; + InvalidateStyleRedraw(); + ReconfigureScrollBars(); + } + break; + + case SCI_GETWRAPVISUALFLAGS: + return wrapVisualFlags; + + case SCI_SETWRAPVISUALFLAGSLOCATION: + wrapVisualFlagsLocation = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETWRAPVISUALFLAGSLOCATION: + return wrapVisualFlagsLocation; + + case SCI_SETWRAPSTARTINDENT: + if (wrapVisualStartIndent != static_cast(wParam)) { + wrapVisualStartIndent = wParam; + InvalidateStyleRedraw(); + ReconfigureScrollBars(); + } + break; + + case SCI_GETWRAPSTARTINDENT: + return wrapVisualStartIndent; + + case SCI_SETWRAPINDENTMODE: + if (wrapIndentMode != static_cast(wParam)) { + wrapIndentMode = wParam; + InvalidateStyleRedraw(); + ReconfigureScrollBars(); + } + break; + + case SCI_GETWRAPINDENTMODE: + return wrapIndentMode; + + case SCI_SETLAYOUTCACHE: + llc.SetLevel(wParam); + break; + + case SCI_GETLAYOUTCACHE: + return llc.GetLevel(); + + case SCI_SETPOSITIONCACHE: + posCache.SetSize(wParam); + break; + + case SCI_GETPOSITIONCACHE: + return posCache.GetSize(); + + case SCI_SETSCROLLWIDTH: + PLATFORM_ASSERT(wParam > 0); + if ((wParam > 0) && (wParam != static_cast(scrollWidth))) { + lineWidthMaxSeen = 0; + scrollWidth = wParam; + SetScrollBars(); + } + break; + + case SCI_GETSCROLLWIDTH: + return scrollWidth; + + case SCI_SETSCROLLWIDTHTRACKING: + trackLineWidth = wParam != 0; + break; + + case SCI_GETSCROLLWIDTHTRACKING: + return trackLineWidth; + + case SCI_LINESJOIN: + LinesJoin(); + break; + + case SCI_LINESSPLIT: + LinesSplit(wParam); + break; + + case SCI_TEXTWIDTH: + PLATFORM_ASSERT(wParam < vs.stylesSize); + PLATFORM_ASSERT(lParam); + return TextWidth(wParam, CharPtrFromSPtr(lParam)); + + case SCI_TEXTHEIGHT: + return vs.lineHeight; + + case SCI_SETENDATLASTLINE: + PLATFORM_ASSERT((wParam == 0) || (wParam == 1)); + if (endAtLastLine != (wParam != 0)) { + endAtLastLine = wParam != 0; + SetScrollBars(); + } + break; + + case SCI_GETENDATLASTLINE: + return endAtLastLine; + + case SCI_SETCARETSTICKY: + PLATFORM_ASSERT((wParam == 0) || (wParam == 1)); + if (caretSticky != (wParam != 0)) { + caretSticky = wParam != 0; + } + break; + + case SCI_GETCARETSTICKY: + return caretSticky; + + case SCI_TOGGLECARETSTICKY: + caretSticky = !caretSticky; + break; + + case SCI_GETCOLUMN: + return pdoc->GetColumn(wParam); + + case SCI_FINDCOLUMN: + return pdoc->FindColumn(wParam, lParam); + + case SCI_SETHSCROLLBAR : + if (horizontalScrollBarVisible != (wParam != 0)) { + horizontalScrollBarVisible = wParam != 0; + SetScrollBars(); + ReconfigureScrollBars(); + } + break; + + case SCI_GETHSCROLLBAR: + return horizontalScrollBarVisible; + + case SCI_SETVSCROLLBAR: + if (verticalScrollBarVisible != (wParam != 0)) { + verticalScrollBarVisible = wParam != 0; + SetScrollBars(); + ReconfigureScrollBars(); + } + break; + + case SCI_GETVSCROLLBAR: + return verticalScrollBarVisible; + + case SCI_SETINDENTATIONGUIDES: + vs.viewIndentationGuides = IndentView(wParam); + Redraw(); + break; + + case SCI_GETINDENTATIONGUIDES: + return vs.viewIndentationGuides; + + case SCI_SETHIGHLIGHTGUIDE: + if ((highlightGuideColumn != static_cast(wParam)) || (wParam > 0)) { + highlightGuideColumn = wParam; + Redraw(); + } + break; + + case SCI_GETHIGHLIGHTGUIDE: + return highlightGuideColumn; + + case SCI_GETLINEENDPOSITION: + return pdoc->LineEnd(wParam); + + case SCI_SETCODEPAGE: + if (ValidCodePage(wParam)) { + pdoc->dbcsCodePage = wParam; + InvalidateStyleRedraw(); + } + break; + + case SCI_GETCODEPAGE: + return pdoc->dbcsCodePage; + + case SCI_SETUSEPALETTE: + palette.allowRealization = wParam != 0; + InvalidateStyleRedraw(); + break; + + case SCI_GETUSEPALETTE: + return palette.allowRealization; + + // Marker definition and setting + case SCI_MARKERDEFINE: + if (wParam <= MARKER_MAX) + vs.markers[wParam].markType = lParam; + InvalidateStyleData(); + RedrawSelMargin(); + break; + + case SCI_MARKERSYMBOLDEFINED: + if (wParam <= MARKER_MAX) + return vs.markers[wParam].markType; + else + return 0; + + case SCI_MARKERSETFORE: + if (wParam <= MARKER_MAX) + vs.markers[wParam].fore.desired = ColourDesired(lParam); + InvalidateStyleData(); + RedrawSelMargin(); + break; + case SCI_MARKERSETBACK: + if (wParam <= MARKER_MAX) + vs.markers[wParam].back.desired = ColourDesired(lParam); + InvalidateStyleData(); + RedrawSelMargin(); + break; + case SCI_MARKERSETALPHA: + if (wParam <= MARKER_MAX) + vs.markers[wParam].alpha = lParam; + InvalidateStyleRedraw(); + break; + case SCI_MARKERADD: { + int markerID = pdoc->AddMark(wParam, lParam); + return markerID; + } + case SCI_MARKERADDSET: + if (lParam != 0) + pdoc->AddMarkSet(wParam, lParam); + break; + + case SCI_MARKERDELETE: + pdoc->DeleteMark(wParam, lParam); + break; + + case SCI_MARKERDELETEALL: + pdoc->DeleteAllMarks(static_cast(wParam)); + break; + + case SCI_MARKERGET: + return pdoc->GetMark(wParam); + + case SCI_MARKERNEXT: { + int lt = pdoc->LinesTotal(); + for (int iLine = wParam; iLine < lt; iLine++) { + if ((pdoc->GetMark(iLine) & lParam) != 0) + return iLine; + } + } + return -1; + + case SCI_MARKERPREVIOUS: { + for (int iLine = wParam; iLine >= 0; iLine--) { + if ((pdoc->GetMark(iLine) & lParam) != 0) + return iLine; + } + } + return -1; + + case SCI_MARKERDEFINEPIXMAP: + if (wParam <= MARKER_MAX) { + vs.markers[wParam].SetXPM(CharPtrFromSPtr(lParam)); + }; + InvalidateStyleData(); + RedrawSelMargin(); + break; + + case SCI_SETMARGINTYPEN: + if (ValidMargin(wParam)) { + vs.ms[wParam].style = lParam; + InvalidateStyleRedraw(); + } + break; + + case SCI_GETMARGINTYPEN: + if (ValidMargin(wParam)) + return vs.ms[wParam].style; + else + return 0; + + case SCI_SETMARGINWIDTHN: + if (ValidMargin(wParam)) { + // Short-circuit if the width is unchanged, to avoid unnecessary redraw. + if (vs.ms[wParam].width != lParam) { + vs.ms[wParam].width = lParam; + InvalidateStyleRedraw(); + } + } + break; + + case SCI_GETMARGINWIDTHN: + if (ValidMargin(wParam)) + return vs.ms[wParam].width; + else + return 0; + + case SCI_SETMARGINMASKN: + if (ValidMargin(wParam)) { + vs.ms[wParam].mask = lParam; + InvalidateStyleRedraw(); + } + break; + + case SCI_GETMARGINMASKN: + if (ValidMargin(wParam)) + return vs.ms[wParam].mask; + else + return 0; + + case SCI_SETMARGINSENSITIVEN: + if (ValidMargin(wParam)) { + vs.ms[wParam].sensitive = lParam != 0; + InvalidateStyleRedraw(); + } + break; + + case SCI_GETMARGINSENSITIVEN: + if (ValidMargin(wParam)) + return vs.ms[wParam].sensitive ? 1 : 0; + else + return 0; + + case SCI_STYLECLEARALL: + vs.ClearStyles(); + InvalidateStyleRedraw(); + break; + + case SCI_STYLESETFORE: + case SCI_STYLESETBACK: + case SCI_STYLESETBOLD: + case SCI_STYLESETITALIC: + case SCI_STYLESETEOLFILLED: + case SCI_STYLESETSIZE: + case SCI_STYLESETFONT: + case SCI_STYLESETUNDERLINE: + case SCI_STYLESETCASE: + case SCI_STYLESETCHARACTERSET: + case SCI_STYLESETVISIBLE: + case SCI_STYLESETCHANGEABLE: + case SCI_STYLESETHOTSPOT: + StyleSetMessage(iMessage, wParam, lParam); + break; + + case SCI_STYLEGETFORE: + case SCI_STYLEGETBACK: + case SCI_STYLEGETBOLD: + case SCI_STYLEGETITALIC: + case SCI_STYLEGETEOLFILLED: + case SCI_STYLEGETSIZE: + case SCI_STYLEGETFONT: + case SCI_STYLEGETUNDERLINE: + case SCI_STYLEGETCASE: + case SCI_STYLEGETCHARACTERSET: + case SCI_STYLEGETVISIBLE: + case SCI_STYLEGETCHANGEABLE: + case SCI_STYLEGETHOTSPOT: + return StyleGetMessage(iMessage, wParam, lParam); + + case SCI_STYLERESETDEFAULT: + vs.ResetDefaultStyle(); + InvalidateStyleRedraw(); + break; + case SCI_SETSTYLEBITS: + vs.EnsureStyle((1 << wParam) - 1); + pdoc->SetStylingBits(wParam); + break; + + case SCI_GETSTYLEBITS: + return pdoc->stylingBits; + + case SCI_SETLINESTATE: + return pdoc->SetLineState(wParam, lParam); + + case SCI_GETLINESTATE: + return pdoc->GetLineState(wParam); + + case SCI_GETMAXLINESTATE: + return pdoc->GetMaxLineState(); + + case SCI_GETCARETLINEVISIBLE: + return vs.showCaretLineBackground; + case SCI_SETCARETLINEVISIBLE: + vs.showCaretLineBackground = wParam != 0; + InvalidateStyleRedraw(); + break; + case SCI_GETCARETLINEBACK: + return vs.caretLineBackground.desired.AsLong(); + case SCI_SETCARETLINEBACK: + vs.caretLineBackground.desired = wParam; + InvalidateStyleRedraw(); + break; + case SCI_GETCARETLINEBACKALPHA: + return vs.caretLineAlpha; + case SCI_SETCARETLINEBACKALPHA: + vs.caretLineAlpha = wParam; + InvalidateStyleRedraw(); + break; + + // Folding messages + + case SCI_VISIBLEFROMDOCLINE: + return cs.DisplayFromDoc(wParam); + + case SCI_DOCLINEFROMVISIBLE: + return cs.DocFromDisplay(wParam); + + case SCI_WRAPCOUNT: + return WrapCount(wParam); + + case SCI_SETFOLDLEVEL: { + int prev = pdoc->SetLevel(wParam, lParam); + if (prev != lParam) + RedrawSelMargin(); + return prev; + } + + case SCI_GETFOLDLEVEL: + return pdoc->GetLevel(wParam); + + case SCI_GETLASTCHILD: + return pdoc->GetLastChild(wParam, lParam); + + case SCI_GETFOLDPARENT: + return pdoc->GetFoldParent(wParam); + + case SCI_SHOWLINES: + cs.SetVisible(wParam, lParam, true); + SetScrollBars(); + Redraw(); + break; + + case SCI_HIDELINES: + if (wParam > 0) + cs.SetVisible(wParam, lParam, false); + SetScrollBars(); + Redraw(); + break; + + case SCI_GETLINEVISIBLE: + return cs.GetVisible(wParam); + + case SCI_SETFOLDEXPANDED: + if (cs.SetExpanded(wParam, lParam != 0)) { + RedrawSelMargin(); + } + break; + + case SCI_GETFOLDEXPANDED: + return cs.GetExpanded(wParam); + + case SCI_SETFOLDFLAGS: + foldFlags = wParam; + Redraw(); + break; + + case SCI_TOGGLEFOLD: + ToggleContraction(wParam); + break; + + case SCI_ENSUREVISIBLE: + EnsureLineVisible(wParam, false); + break; + + case SCI_ENSUREVISIBLEENFORCEPOLICY: + EnsureLineVisible(wParam, true); + break; + + case SCI_SEARCHANCHOR: + SearchAnchor(); + break; + + case SCI_SEARCHNEXT: + case SCI_SEARCHPREV: + return SearchText(iMessage, wParam, lParam); + + case SCI_SETXCARETPOLICY: + caretXPolicy = wParam; + caretXSlop = lParam; + break; + + case SCI_SETYCARETPOLICY: + caretYPolicy = wParam; + caretYSlop = lParam; + break; + + case SCI_SETVISIBLEPOLICY: + visiblePolicy = wParam; + visibleSlop = lParam; + break; + + case SCI_LINESONSCREEN: + return LinesOnScreen(); + + case SCI_SETSELFORE: + vs.selforeset = wParam != 0; + vs.selforeground.desired = ColourDesired(lParam); + vs.selAdditionalForeground.desired = ColourDesired(lParam); + InvalidateStyleRedraw(); + break; + + case SCI_SETSELBACK: + vs.selbackset = wParam != 0; + vs.selbackground.desired = ColourDesired(lParam); + vs.selAdditionalBackground.desired = ColourDesired(lParam); + InvalidateStyleRedraw(); + break; + + case SCI_SETSELALPHA: + vs.selAlpha = wParam; + vs.selAdditionalAlpha = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETSELALPHA: + return vs.selAlpha; + + case SCI_GETSELEOLFILLED: + return vs.selEOLFilled; + + case SCI_SETSELEOLFILLED: + vs.selEOLFilled = wParam != 0; + InvalidateStyleRedraw(); + break; + + case SCI_SETWHITESPACEFORE: + vs.whitespaceForegroundSet = wParam != 0; + vs.whitespaceForeground.desired = ColourDesired(lParam); + InvalidateStyleRedraw(); + break; + + case SCI_SETWHITESPACEBACK: + vs.whitespaceBackgroundSet = wParam != 0; + vs.whitespaceBackground.desired = ColourDesired(lParam); + InvalidateStyleRedraw(); + break; + + case SCI_SETCARETFORE: + vs.caretcolour.desired = ColourDesired(wParam); + InvalidateStyleRedraw(); + break; + + case SCI_GETCARETFORE: + return vs.caretcolour.desired.AsLong(); + + case SCI_SETCARETSTYLE: + if (wParam >= CARETSTYLE_INVISIBLE && wParam <= CARETSTYLE_BLOCK) + vs.caretStyle = wParam; + else + /* Default to the line caret */ + vs.caretStyle = CARETSTYLE_LINE; + InvalidateStyleRedraw(); + break; + + case SCI_GETCARETSTYLE: + return vs.caretStyle; + + case SCI_SETCARETWIDTH: + if (wParam <= 0) + vs.caretWidth = 0; + else if (wParam >= 3) + vs.caretWidth = 3; + else + vs.caretWidth = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETCARETWIDTH: + return vs.caretWidth; + + case SCI_ASSIGNCMDKEY: + kmap.AssignCmdKey(Platform::LowShortFromLong(wParam), + Platform::HighShortFromLong(wParam), lParam); + break; + + case SCI_CLEARCMDKEY: + kmap.AssignCmdKey(Platform::LowShortFromLong(wParam), + Platform::HighShortFromLong(wParam), SCI_NULL); + break; + + case SCI_CLEARALLCMDKEYS: + kmap.Clear(); + break; + + case SCI_INDICSETSTYLE: + if (wParam <= INDIC_MAX) { + vs.indicators[wParam].style = lParam; + InvalidateStyleRedraw(); + } + break; + + case SCI_INDICGETSTYLE: + return (wParam <= INDIC_MAX) ? vs.indicators[wParam].style : 0; + + case SCI_INDICSETFORE: + if (wParam <= INDIC_MAX) { + vs.indicators[wParam].fore.desired = ColourDesired(lParam); + InvalidateStyleRedraw(); + } + break; + + case SCI_INDICGETFORE: + return (wParam <= INDIC_MAX) ? vs.indicators[wParam].fore.desired.AsLong() : 0; + + case SCI_INDICSETUNDER: + if (wParam <= INDIC_MAX) { + vs.indicators[wParam].under = lParam != 0; + InvalidateStyleRedraw(); + } + break; + + case SCI_INDICGETUNDER: + return (wParam <= INDIC_MAX) ? vs.indicators[wParam].under : 0; + + case SCI_INDICSETALPHA: + if (wParam <= INDIC_MAX && lParam >=0 && lParam <= 100) { + vs.indicators[wParam].fillAlpha = lParam; + InvalidateStyleRedraw(); + } + break; + + case SCI_INDICGETALPHA: + return (wParam <= INDIC_MAX) ? vs.indicators[wParam].fillAlpha : 0; + + case SCI_SETINDICATORCURRENT: + pdoc->decorations.SetCurrentIndicator(wParam); + break; + case SCI_GETINDICATORCURRENT: + return pdoc->decorations.GetCurrentIndicator(); + case SCI_SETINDICATORVALUE: + pdoc->decorations.SetCurrentValue(wParam); + break; + case SCI_GETINDICATORVALUE: + return pdoc->decorations.GetCurrentValue(); + + case SCI_INDICATORFILLRANGE: + pdoc->DecorationFillRange(wParam, pdoc->decorations.GetCurrentValue(), lParam); + break; + + case SCI_INDICATORCLEARRANGE: + pdoc->DecorationFillRange(wParam, 0, lParam); + break; + + case SCI_INDICATORALLONFOR: + return pdoc->decorations.AllOnFor(wParam); + + case SCI_INDICATORVALUEAT: + return pdoc->decorations.ValueAt(wParam, lParam); + + case SCI_INDICATORSTART: + return pdoc->decorations.Start(wParam, lParam); + + case SCI_INDICATOREND: + return pdoc->decorations.End(wParam, lParam); + + case SCI_LINEDOWN: + case SCI_LINEDOWNEXTEND: + case SCI_PARADOWN: + case SCI_PARADOWNEXTEND: + case SCI_LINEUP: + case SCI_LINEUPEXTEND: + case SCI_PARAUP: + case SCI_PARAUPEXTEND: + case SCI_CHARLEFT: + case SCI_CHARLEFTEXTEND: + case SCI_CHARRIGHT: + case SCI_CHARRIGHTEXTEND: + case SCI_WORDLEFT: + case SCI_WORDLEFTEXTEND: + case SCI_WORDRIGHT: + case SCI_WORDRIGHTEXTEND: + case SCI_WORDLEFTEND: + case SCI_WORDLEFTENDEXTEND: + case SCI_WORDRIGHTEND: + case SCI_WORDRIGHTENDEXTEND: + case SCI_HOME: + case SCI_HOMEEXTEND: + case SCI_LINEEND: + case SCI_LINEENDEXTEND: + case SCI_HOMEWRAP: + case SCI_HOMEWRAPEXTEND: + case SCI_LINEENDWRAP: + case SCI_LINEENDWRAPEXTEND: + case SCI_DOCUMENTSTART: + case SCI_DOCUMENTSTARTEXTEND: + case SCI_DOCUMENTEND: + case SCI_DOCUMENTENDEXTEND: + + case SCI_STUTTEREDPAGEUP: + case SCI_STUTTEREDPAGEUPEXTEND: + case SCI_STUTTEREDPAGEDOWN: + case SCI_STUTTEREDPAGEDOWNEXTEND: + + case SCI_PAGEUP: + case SCI_PAGEUPEXTEND: + case SCI_PAGEDOWN: + case SCI_PAGEDOWNEXTEND: + case SCI_EDITTOGGLEOVERTYPE: + case SCI_CANCEL: + case SCI_DELETEBACK: + case SCI_TAB: + case SCI_BACKTAB: + case SCI_NEWLINE: + case SCI_FORMFEED: + case SCI_VCHOME: + case SCI_VCHOMEEXTEND: + case SCI_VCHOMEWRAP: + case SCI_VCHOMEWRAPEXTEND: + case SCI_ZOOMIN: + case SCI_ZOOMOUT: + case SCI_DELWORDLEFT: + case SCI_DELWORDRIGHT: + case SCI_DELWORDRIGHTEND: + case SCI_DELLINELEFT: + case SCI_DELLINERIGHT: + case SCI_LINECOPY: + case SCI_LINECUT: + case SCI_LINEDELETE: + case SCI_LINETRANSPOSE: + case SCI_LINEDUPLICATE: + case SCI_LOWERCASE: + case SCI_UPPERCASE: + case SCI_LINESCROLLDOWN: + case SCI_LINESCROLLUP: + case SCI_WORDPARTLEFT: + case SCI_WORDPARTLEFTEXTEND: + case SCI_WORDPARTRIGHT: + case SCI_WORDPARTRIGHTEXTEND: + case SCI_DELETEBACKNOTLINE: + case SCI_HOMEDISPLAY: + case SCI_HOMEDISPLAYEXTEND: + case SCI_LINEENDDISPLAY: + case SCI_LINEENDDISPLAYEXTEND: + case SCI_LINEDOWNRECTEXTEND: + case SCI_LINEUPRECTEXTEND: + case SCI_CHARLEFTRECTEXTEND: + case SCI_CHARRIGHTRECTEXTEND: + case SCI_HOMERECTEXTEND: + case SCI_VCHOMERECTEXTEND: + case SCI_LINEENDRECTEXTEND: + case SCI_PAGEUPRECTEXTEND: + case SCI_PAGEDOWNRECTEXTEND: + case SCI_SELECTIONDUPLICATE: + return KeyCommand(iMessage); + + case SCI_BRACEHIGHLIGHT: + SetBraceHighlight(static_cast(wParam), lParam, STYLE_BRACELIGHT); + break; + + case SCI_BRACEBADLIGHT: + SetBraceHighlight(static_cast(wParam), -1, STYLE_BRACEBAD); + break; + + case SCI_BRACEMATCH: + // wParam is position of char to find brace for, + // lParam is maximum amount of text to restyle to find it + return pdoc->BraceMatch(wParam, lParam); + + case SCI_GETVIEWEOL: + return vs.viewEOL; + + case SCI_SETVIEWEOL: + vs.viewEOL = wParam != 0; + InvalidateStyleRedraw(); + break; + + case SCI_SETZOOM: + vs.zoomLevel = wParam; + InvalidateStyleRedraw(); + NotifyZoom(); + break; + + case SCI_GETZOOM: + return vs.zoomLevel; + + case SCI_GETEDGECOLUMN: + return theEdge; + + case SCI_SETEDGECOLUMN: + theEdge = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETEDGEMODE: + return vs.edgeState; + + case SCI_SETEDGEMODE: + vs.edgeState = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETEDGECOLOUR: + return vs.edgecolour.desired.AsLong(); + + case SCI_SETEDGECOLOUR: + vs.edgecolour.desired = ColourDesired(wParam); + InvalidateStyleRedraw(); + break; + + case SCI_GETDOCPOINTER: + return reinterpret_cast(pdoc); + + case SCI_SETDOCPOINTER: + CancelModes(); + SetDocPointer(reinterpret_cast(lParam)); + return 0; + + case SCI_CREATEDOCUMENT: { + Document *doc = new Document(); + if (doc) { + doc->AddRef(); + } + return reinterpret_cast(doc); + } + + case SCI_ADDREFDOCUMENT: + (reinterpret_cast(lParam))->AddRef(); + break; + + case SCI_RELEASEDOCUMENT: + (reinterpret_cast(lParam))->Release(); + break; + + case SCI_SETMODEVENTMASK: + modEventMask = wParam; + return 0; + + case SCI_GETMODEVENTMASK: + return modEventMask; + + case SCI_CONVERTEOLS: + pdoc->ConvertLineEnds(wParam); + SetSelection(sel.MainCaret(), sel.MainAnchor()); // Ensure selection inside document + return 0; + + case SCI_SETLENGTHFORENCODE: + lengthForEncode = wParam; + return 0; + + case SCI_SELECTIONISRECTANGLE: + return sel.selType == Selection::selRectangle ? 1 : 0; + + case SCI_SETSELECTIONMODE: { + switch (wParam) { + case SC_SEL_STREAM: + sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selStream)); + sel.selType = Selection::selStream; + break; + case SC_SEL_RECTANGLE: + sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selRectangle)); + sel.selType = Selection::selRectangle; + break; + case SC_SEL_LINES: + sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selLines)); + sel.selType = Selection::selLines; + break; + case SC_SEL_THIN: + sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selThin)); + sel.selType = Selection::selThin; + break; + default: + sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selStream)); + sel.selType = Selection::selStream; + } + InvalidateSelection(sel.RangeMain(), true); + } + case SCI_GETSELECTIONMODE: + switch (sel.selType) { + case Selection::selStream: + return SC_SEL_STREAM; + case Selection::selRectangle: + return SC_SEL_RECTANGLE; + case Selection::selLines: + return SC_SEL_LINES; + case Selection::selThin: + return SC_SEL_THIN; + default: // ?! + return SC_SEL_STREAM; + } + case SCI_GETLINESELSTARTPOSITION: + case SCI_GETLINESELENDPOSITION: { + SelectionSegment segmentLine(SelectionPosition(pdoc->LineStart(wParam)), + SelectionPosition(pdoc->LineEnd(wParam))); + for (size_t r=0; r(pdoc->BufferPointer()); + + case SCI_SETEXTRAASCENT: + vs.extraAscent = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETEXTRAASCENT: + return vs.extraAscent; + + case SCI_SETEXTRADESCENT: + vs.extraDescent = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETEXTRADESCENT: + return vs.extraDescent; + + case SCI_MARGINSETSTYLEOFFSET: + vs.marginStyleOffset = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_MARGINGETSTYLEOFFSET: + return vs.marginStyleOffset; + + case SCI_MARGINSETTEXT: + pdoc->MarginSetText(wParam, CharPtrFromSPtr(lParam)); + break; + + case SCI_MARGINGETTEXT: { + const StyledText st = pdoc->MarginStyledText(wParam); + if (lParam) { + if (st.text) + memcpy(CharPtrFromSPtr(lParam), st.text, st.length); + else + strcpy(CharPtrFromSPtr(lParam), ""); + } + return st.length; + } + + case SCI_MARGINSETSTYLE: + pdoc->MarginSetStyle(wParam, lParam); + break; + + case SCI_MARGINGETSTYLE: { + const StyledText st = pdoc->MarginStyledText(wParam); + return st.style; + } + + case SCI_MARGINSETSTYLES: + pdoc->MarginSetStyles(wParam, reinterpret_cast(lParam)); + break; + + case SCI_MARGINGETSTYLES: { + const StyledText st = pdoc->MarginStyledText(wParam); + if (lParam) { + if (st.styles) + memcpy(CharPtrFromSPtr(lParam), st.styles, st.length); + else + strcpy(CharPtrFromSPtr(lParam), ""); + } + return st.styles ? st.length : 0; + } + + case SCI_MARGINTEXTCLEARALL: + pdoc->MarginClearAll(); + break; + + case SCI_ANNOTATIONSETTEXT: + pdoc->AnnotationSetText(wParam, CharPtrFromSPtr(lParam)); + break; + + case SCI_ANNOTATIONGETTEXT: { + const StyledText st = pdoc->AnnotationStyledText(wParam); + if (lParam) { + if (st.text) + memcpy(CharPtrFromSPtr(lParam), st.text, st.length); + else + strcpy(CharPtrFromSPtr(lParam), ""); + } + return st.length; + } + + case SCI_ANNOTATIONGETSTYLE: { + const StyledText st = pdoc->AnnotationStyledText(wParam); + return st.style; + } + + case SCI_ANNOTATIONSETSTYLE: + pdoc->AnnotationSetStyle(wParam, lParam); + break; + + case SCI_ANNOTATIONSETSTYLES: + pdoc->AnnotationSetStyles(wParam, reinterpret_cast(lParam)); + break; + + case SCI_ANNOTATIONGETSTYLES: { + const StyledText st = pdoc->AnnotationStyledText(wParam); + if (lParam) { + if (st.styles) + memcpy(CharPtrFromSPtr(lParam), st.styles, st.length); + else + strcpy(CharPtrFromSPtr(lParam), ""); + } + return st.styles ? st.length : 0; + } + + case SCI_ANNOTATIONGETLINES: + return pdoc->AnnotationLines(wParam); + + case SCI_ANNOTATIONCLEARALL: + pdoc->AnnotationClearAll(); + break; + + case SCI_ANNOTATIONSETVISIBLE: + SetAnnotationVisible(wParam); + break; + + case SCI_ANNOTATIONGETVISIBLE: + return vs.annotationVisible; + + case SCI_ANNOTATIONSETSTYLEOFFSET: + vs.annotationStyleOffset = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_ANNOTATIONGETSTYLEOFFSET: + return vs.annotationStyleOffset; + + case SCI_ADDUNDOACTION: + pdoc->AddUndoAction(wParam, lParam & UNDO_MAY_COALESCE); + break; + + case SCI_SETMULTIPLESELECTION: + multipleSelection = wParam != 0; + InvalidateCaret(); + break; + + case SCI_GETMULTIPLESELECTION: + return multipleSelection; + + case SCI_SETADDITIONALSELECTIONTYPING: + additionalSelectionTyping = wParam != 0; + InvalidateCaret(); + break; + + case SCI_GETADDITIONALSELECTIONTYPING: + return additionalSelectionTyping; + + case SCI_SETMULTIPASTE: + multiPasteMode = wParam; + break; + + case SCI_GETMULTIPASTE: + return multiPasteMode; + + case SCI_SETADDITIONALCARETSBLINK: + additionalCaretsBlink = wParam != 0; + InvalidateCaret(); + break; + + case SCI_GETADDITIONALCARETSBLINK: + return additionalCaretsBlink; + + case SCI_SETADDITIONALCARETSVISIBLE: + additionalCaretsVisible = wParam != 0; + InvalidateCaret(); + break; + + case SCI_GETADDITIONALCARETSVISIBLE: + return additionalCaretsVisible; + + case SCI_GETSELECTIONS: + return sel.Count(); + + case SCI_CLEARSELECTIONS: + sel.Clear(); + Redraw(); + break; + + case SCI_SETSELECTION: + sel.SetSelection(SelectionRange(wParam, lParam)); + Redraw(); + break; + + case SCI_ADDSELECTION: + sel.AddSelection(SelectionRange(wParam, lParam)); + Redraw(); + break; + + case SCI_SETMAINSELECTION: + sel.SetMain(wParam); + Redraw(); + break; + + case SCI_GETMAINSELECTION: + return sel.Main(); + + case SCI_SETSELECTIONNCARET: + sel.Range(wParam).caret.SetPosition(lParam); + Redraw(); + break; + + case SCI_GETSELECTIONNCARET: + return sel.Range(wParam).caret.Position(); + + case SCI_SETSELECTIONNANCHOR: + sel.Range(wParam).anchor.SetPosition(lParam); + Redraw(); + break; + case SCI_GETSELECTIONNANCHOR: + return sel.Range(wParam).anchor.Position(); + + case SCI_SETSELECTIONNCARETVIRTUALSPACE: + sel.Range(wParam).caret.SetVirtualSpace(lParam); + Redraw(); + break; + + case SCI_GETSELECTIONNCARETVIRTUALSPACE: + return sel.Range(wParam).caret.VirtualSpace(); + + case SCI_SETSELECTIONNANCHORVIRTUALSPACE: + sel.Range(wParam).anchor.SetVirtualSpace(lParam); + Redraw(); + break; + + case SCI_GETSELECTIONNANCHORVIRTUALSPACE: + return sel.Range(wParam).anchor.VirtualSpace(); + + case SCI_SETSELECTIONNSTART: + sel.Range(wParam).anchor.SetPosition(lParam); + Redraw(); + break; + + case SCI_GETSELECTIONNSTART: + return sel.Range(wParam).Start().Position(); + + case SCI_SETSELECTIONNEND: + sel.Range(wParam).caret.SetPosition(lParam); + Redraw(); + break; + + case SCI_GETSELECTIONNEND: + return sel.Range(wParam).End().Position(); + + case SCI_SETRECTANGULARSELECTIONCARET: + if (!sel.IsRectangular()) + sel.Clear(); + sel.selType = Selection::selRectangle; + sel.Rectangular().caret.SetPosition(wParam); + SetRectangularRange(); + Redraw(); + break; + + case SCI_GETRECTANGULARSELECTIONCARET: + return sel.Rectangular().caret.Position(); + + case SCI_SETRECTANGULARSELECTIONANCHOR: + if (!sel.IsRectangular()) + sel.Clear(); + sel.selType = Selection::selRectangle; + sel.Rectangular().anchor.SetPosition(wParam); + SetRectangularRange(); + Redraw(); + break; + + case SCI_GETRECTANGULARSELECTIONANCHOR: + return sel.Rectangular().anchor.Position(); + + case SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE: + if (!sel.IsRectangular()) + sel.Clear(); + sel.selType = Selection::selRectangle; + sel.Rectangular().caret.SetVirtualSpace(wParam); + SetRectangularRange(); + Redraw(); + break; + + case SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE: + return sel.Rectangular().caret.VirtualSpace(); + + case SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE: + if (!sel.IsRectangular()) + sel.Clear(); + sel.selType = Selection::selRectangle; + sel.Rectangular().anchor.SetVirtualSpace(wParam); + SetRectangularRange(); + Redraw(); + break; + + case SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE: + return sel.Rectangular().anchor.VirtualSpace(); + + case SCI_SETVIRTUALSPACEOPTIONS: + virtualSpaceOptions = wParam; + break; + + case SCI_GETVIRTUALSPACEOPTIONS: + return virtualSpaceOptions; + + case SCI_SETADDITIONALSELFORE: + vs.selAdditionalForeground.desired = ColourDesired(wParam); + InvalidateStyleRedraw(); + break; + + case SCI_SETADDITIONALSELBACK: + vs.selAdditionalBackground.desired = ColourDesired(wParam); + InvalidateStyleRedraw(); + break; + + case SCI_SETADDITIONALSELALPHA: + vs.selAdditionalAlpha = wParam; + InvalidateStyleRedraw(); + break; + + case SCI_GETADDITIONALSELALPHA: + return vs.selAdditionalAlpha; + + case SCI_SETADDITIONALCARETFORE: + vs.additionalCaretColour.desired = ColourDesired(wParam); + InvalidateStyleRedraw(); + break; + + case SCI_GETADDITIONALCARETFORE: + return vs.additionalCaretColour.desired.AsLong(); + + case SCI_ROTATESELECTION: + sel.RotateMain(); + InvalidateSelection(sel.RangeMain(), true); + break; + + case SCI_SWAPMAINANCHORCARET: + InvalidateSelection(sel.RangeMain()); + sel.RangeMain() = SelectionRange(sel.RangeMain().anchor, sel.RangeMain().caret); + break; + + default: + return DefWndProc(iMessage, wParam, lParam); + } + //Platform::DebugPrintf("end wnd proc\n"); + return 0l; +} diff --git a/sdk/wxscintilla/src/scintilla/src/Editor.h b/sdk/wxscintilla/src/scintilla/src/Editor.h new file mode 100644 index 0000000..d3df42d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Editor.h @@ -0,0 +1,590 @@ +// Scintilla source code edit control +/** @file Editor.h + ** Defines the main editor class. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef EDITOR_H +#define EDITOR_H + +// Eran Ifrah +#include +// Eran Ifrah - END + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ +class Caret { +public: + bool active; + bool on; + int period; + + Caret(); +}; + +/** + */ +class Timer { +public: + bool ticking; + int ticksToWait; + enum {tickSize = 100}; + TickerID tickerID; + + Timer(); +}; + +/** + */ +class Idler { +public: + bool state; + IdlerID idlerID; + + Idler(); +}; + +/** + * When platform has a way to generate an event before painting, + * accumulate needed styling range in StyleNeeded to avoid unnecessary work. + */ +class StyleNeeded { +public: + bool active; + Position upTo; + + StyleNeeded() : active(false), upTo(0) {} + void Reset() { + active = false; + upTo = 0; + } + void NeedUpTo(Position pos) { + if (upTo < pos) + upTo = pos; + } +}; + +/** + * Hold a piece of text selected for copying or dragging. + * The text is expected to hold a terminating '\0' and this is counted in len. + */ +class SelectionText { +public: + char *s; + int len; + bool rectangular; + bool lineCopy; + int codePage; + int characterSet; + SelectionText() : s(0), len(0), rectangular(false), lineCopy(false), codePage(0), characterSet(0) {} + ~SelectionText() { + Free(); + } + void Free() { + Set(0, 0, 0, 0, false, false); + } + void Set(char *s_, int len_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) { + delete []s; + s = s_; + if (s) + len = len_; + else + len = 0; + codePage = codePage_; + characterSet = characterSet_; + rectangular = rectangular_; + lineCopy = lineCopy_; + } + void Copy(const char *s_, int len_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) { + delete []s; + s = 0; + s = new char[len_]; + len = len_; + for (int i = 0; i < len_; i++) { + s[i] = s_[i]; + } + codePage = codePage_; + characterSet = characterSet_; + rectangular = rectangular_; + lineCopy = lineCopy_; + } + void Copy(const SelectionText &other) { + Copy(other.s, other.len, other.codePage, other.characterSet, other.rectangular, other.lineCopy); + } +}; + +/** + */ +class Editor : public DocWatcher { + // Private so Editor objects can not be copied + Editor(const Editor &); + Editor &operator=(const Editor &); + +protected: // ScintillaBase subclass needs access to much of Editor + + /** On GTK+, Scintilla is a container widget holding two scroll bars + * whereas on Windows there is just one window with both scroll bars turned on. */ + Window wMain; ///< The Scintilla parent window + + /** Style resources may be expensive to allocate so are cached between uses. + * When a style attribute is changed, this cache is flushed. */ + bool stylesValid; + ViewStyle vs; + Palette palette; + + int printMagnification; + int printColourMode; + int printWrapState; + int cursorMode; + int controlCharSymbol; + + bool hasFocus; + bool hideSelection; + bool inOverstrike; + bool mouseDownCaptures; + + /** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to + * the screen. This avoids flashing but is about 30% slower. */ + bool bufferedDraw; + /** In twoPhaseDraw mode, drawing is performed in two phases, first the background + * and then the foreground. This avoids chopping off characters that overlap the next run. */ + bool twoPhaseDraw; + + int xOffset; ///< Horizontal scrolled amount in pixels + int xCaretMargin; ///< Ensure this many pixels visible on both sides of caret + bool horizontalScrollBarVisible; + int scrollWidth; + bool trackLineWidth; + int lineWidthMaxSeen; + bool verticalScrollBarVisible; + bool endAtLastLine; + bool caretSticky; + bool multipleSelection; + bool additionalSelectionTyping; + int multiPasteMode; + bool additionalCaretsBlink; + bool additionalCaretsVisible; + + int virtualSpaceOptions; + + Surface *pixmapLine; + Surface *pixmapSelMargin; + Surface *pixmapSelPattern; + Surface *pixmapIndentGuide; + Surface *pixmapIndentGuideHighlight; + + LineLayoutCache llc; + PositionCache posCache; + + KeyMap kmap; + + Caret caret; + Timer timer; + Timer autoScrollTimer; + enum { autoScrollDelay = 200 }; + + Idler idler; + + Point lastClick; + unsigned int lastClickTime; + int dwellDelay; + int ticksToDwell; + bool dwelling; + enum { selChar, selWord, selLine } selectionType; + Point ptMouseLast; + enum { ddNone, ddInitial, ddDragging } inDragDrop; + bool dropWentOutside; + SelectionPosition posDrag; + SelectionPosition posDrop; + int lastXChosen; + int lineAnchor; + int originalAnchorPos; + int targetStart; + int targetEnd; + int searchFlags; + int topLine; + int posTopLine; + int lengthForEncode; + + bool needUpdateUI; + Position braces[2]; + int bracesMatchStyle; + int highlightGuideColumn; + + int theEdge; + + enum { notPainting, painting, paintAbandoned } paintState; + PRectangle rcPaint; + bool paintingAllText; + StyleNeeded styleNeeded; + + int modEventMask; + + SelectionText drag; + Selection sel; + bool primarySelection; + + int caretXPolicy; + int caretXSlop; ///< Ensure this many pixels visible on both sides of caret + + int caretYPolicy; + int caretYSlop; ///< Ensure this many lines visible on both sides of caret + + int visiblePolicy; + int visibleSlop; + + int searchAnchor; + + bool recordingMacro; + + int foldFlags; + ContractionState cs; + + // Hotspot support + int hsStart; + int hsEnd; + + // Wrapping support + enum { eWrapNone, eWrapWord, eWrapChar } wrapState; + enum { wrapLineLarge = 0x7ffffff }; + int wrapWidth; + int wrapStart; + int wrapEnd; + int wrapVisualFlags; + int wrapVisualFlagsLocation; + int wrapVisualStartIndent; + int wrapAddIndent; // This will be added to initial indent of line + int wrapIndentMode; // SC_WRAPINDENT_FIXED, _SAME, _INDENT + + bool convertPastes; + + Document *pdoc; + + Editor(); + virtual ~Editor(); + virtual void Initialise() = 0; + virtual void Finalise(); + + void InvalidateStyleData(); + void InvalidateStyleRedraw(); + virtual void RefreshColourPalette(Palette &pal, bool want); + void RefreshStyleData(); + void DropGraphics(); + + virtual PRectangle GetClientRectangle(); + PRectangle GetTextRectangle(); + + int LinesOnScreen(); + int LinesToScroll(); + int MaxScrollPos(); + SelectionPosition ClampPositionIntoDocument(SelectionPosition sp) const; + Point LocationFromPosition(SelectionPosition pos); + Point LocationFromPosition(int pos); + int XFromPosition(int pos); + int XFromPosition(SelectionPosition sp); + SelectionPosition SPositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false, bool virtualSpace=true); + int PositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false); + SelectionPosition SPositionFromLineX(int lineDoc, int x); + int PositionFromLineX(int line, int x); + int LineFromLocation(Point pt); + void SetTopLine(int topLineNew); + + bool AbandonPaint(); + void RedrawRect(PRectangle rc); + void Redraw(); + void RedrawSelMargin(int line=-1, bool allAfter=false); + PRectangle RectangleFromRange(int start, int end); + void InvalidateRange(int start, int end); + + bool UserVirtualSpace() const { + return ((virtualSpaceOptions & SCVS_USERACCESSIBLE) != 0); + } + int CurrentPosition(); + bool SelectionEmpty(); + SelectionPosition SelectionStart(); + SelectionPosition SelectionEnd(); + void SetRectangularRange(); + void ThinRectangularRange(); + void InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection=false); + void SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_); + void SetSelection(int currentPos_, int anchor_); + void SetSelection(SelectionPosition currentPos_); + void SetSelection(int currentPos_); + void SetEmptySelection(SelectionPosition currentPos_); + void SetEmptySelection(int currentPos_); + bool RangeContainsProtected(int start, int end) const; + bool SelectionContainsProtected(); + int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true) const; + SelectionPosition MovePositionOutsideChar(SelectionPosition pos, int moveDir, bool checkLineEnd=true) const; + int MovePositionTo(SelectionPosition newPos, Selection::selTypes sel=Selection::noSel, bool ensureVisible=true); + int MovePositionTo(int newPos, Selection::selTypes sel=Selection::noSel, bool ensureVisible=true); + SelectionPosition MovePositionSoVisible(SelectionPosition pos, int moveDir); + SelectionPosition MovePositionSoVisible(int pos, int moveDir); + Point PointMainCaret(); + void SetLastXChosen(); + + void ScrollTo(int line, bool moveThumb=true); + virtual void ScrollText(int linesToMove); + void HorizontalScrollTo(int xPos); + void MoveCaretInsideView(bool ensureVisible=true); + int DisplayFromPosition(int pos); + + struct XYScrollPosition { + int xOffset; + int topLine; + XYScrollPosition(int xOffset_, int topLine_) : xOffset(xOffset_), topLine(topLine_) {} + }; + XYScrollPosition XYScrollToMakeVisible(const bool useMargin, const bool vert, const bool horiz); + void SetXYScroll(XYScrollPosition newXY); + void EnsureCaretVisible(bool useMargin=true, bool vert=true, bool horiz=true); + void ShowCaretAtCurrentPosition(); + void DropCaret(); + void InvalidateCaret(); + virtual void UpdateSystemCaret(); + + void NeedWrapping(int docLineStart = 0, int docLineEnd = wrapLineLarge); + bool WrapOneLine(Surface *surface, int lineToWrap); + bool WrapLines(bool fullWrap, int priorityWrapLineStart); + void LinesJoin(); + void LinesSplit(int pixelWidth); + + int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault); + void PaintSelMargin(Surface *surface, PRectangle &rc); + LineLayout *RetrieveLineLayout(int lineNumber); + void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll, + int width=LineLayout::wrapWidthInfinite); + ColourAllocated SelectionBackground(ViewStyle &vsDraw, bool main); + ColourAllocated TextBackground(ViewStyle &vsDraw, bool overrideBackground, ColourAllocated background, int inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll); + void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight); + void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourAllocated wrapColour); + void DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll, + int line, int lineEnd, int xStart, int subLine, int subLineStart, + bool overrideBackground, ColourAllocated background, + bool drawWrapMark, ColourAllocated wrapColour); + void DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under); + void DrawAnnotation(Surface *surface, ViewStyle &vsDraw, int line, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine); + void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine); + void DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine, + int xStart, int offset, int posCaret, PRectangle rcCaret, ColourAllocated caretColour); + void DrawCarets(Surface *surface, ViewStyle &vsDraw, int line, int xStart, + PRectangle rcLine, LineLayout *ll, int subLine); + void RefreshPixMaps(Surface *surfaceWindow); + void Paint(Surface *surfaceWindow, PRectangle rcArea); + long FormatRange(bool draw, Sci_RangeToFormat *pfr); + int TextWidth(int style, const char *text); + + virtual void SetVerticalScrollPos() = 0; + virtual void SetHorizontalScrollPos() = 0; + virtual bool ModifyScrollBars(int nMax, int nPage) = 0; + virtual void ReconfigureScrollBars(); + void SetScrollBars(); + void ChangeSize(); + + void FilterSelections(); + int InsertSpace(int position, unsigned int spaces); + void AddChar(char ch); + virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false); + void InsertPaste(SelectionPosition selStart, const char *text, int len); + void ClearSelection(); + void ClearAll(); + void ClearDocumentStyle(); + void Cut(); + void PasteRectangular(SelectionPosition pos, const char *ptr, int len); + virtual void Copy() = 0; + virtual void CopyAllowLine(); + virtual bool CanPaste(); + virtual void Paste() = 0; + void Clear(); + void SelectAll(); + void Undo(); + void Redo(); + void DelChar(); + void DelCharBack(bool allowLineStartDeletion); + virtual void ClaimSelection() = 0; + + virtual void NotifyChange() = 0; + virtual void NotifyFocus(bool focus); + virtual int GetCtrlID() { return ctrlID; } + virtual void NotifyParent(SCNotification scn) = 0; + virtual void NotifyStyleToNeeded(int endStyleNeeded); + void NotifyChar(int ch); + void NotifySavePoint(bool isSavePoint); + void NotifyModifyAttempt(); + virtual void NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt); + void NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt); + void NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt); + void NotifyUpdateUI(); + void NotifyPainted(); + void NotifyIndicatorClick(bool click, int position, bool shift, bool ctrl, bool alt); + bool NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt); + void NotifyNeedShown(int pos, int len); + void NotifyDwelling(Point pt, bool state); + void NotifyZoom(); + + void NotifyModifyAttempt(Document *document, void *userData); + void NotifySavePoint(Document *document, void *userData, bool atSavePoint); + void CheckModificationForWrap(DocModification mh); + void NotifyModified(Document *document, DocModification mh, void *userData); + void NotifyDeleted(Document *document, void *userData); + void NotifyStyleNeeded(Document *doc, void *userData, int endPos); + void NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam); + + void PageMove(int direction, Selection::selTypes sel=Selection::noSel, bool stuttered = false); + enum { cmSame, cmUpper, cmLower } caseMap; + virtual std::string CaseMapString(const std::string &s, int caseMapping); + void ChangeCaseOfSelection(int caseMapping); + void LineTranspose(); + void Duplicate(bool forLine); + virtual void CancelModes(); + void NewLine(); + void CursorUpOrDown(int direction, Selection::selTypes sel=Selection::noSel); + void ParaUpOrDown(int direction, Selection::selTypes sel=Selection::noSel); + int StartEndDisplayLine(int pos, bool start); + virtual int KeyCommand(unsigned int iMessage); + virtual int KeyDefault(int /* key */, int /*modifiers*/); + int KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed=0); + + int GetWhitespaceVisible(); + void SetWhitespaceVisible(int view); + + void Indent(bool forwards); + + virtual CaseFolder *CaseFolderForEncoding(); + long FindText(uptr_t wParam, sptr_t lParam); + void SearchAnchor(); + long SearchText(unsigned int iMessage, uptr_t wParam, sptr_t lParam); + long SearchInTarget(const char *text, int length); + void GoToLine(int lineNo); + + virtual void CopyToClipboard(const SelectionText &selectedText) = 0; + char *CopyRange(int start, int end); + void CopySelectionRange(SelectionText *ss, bool allowLineCopy=false); + void CopyRangeToClipboard(int start, int end); + void CopyText(int length, const char *text); + void SetDragPosition(SelectionPosition newPos); + virtual void DisplayCursor(Window::Cursor c); + virtual bool DragThreshold(Point ptStart, Point ptNow); + virtual void StartDrag(); + void DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular); + /** PositionInSelection returns true if position in selection. */ + bool PositionInSelection(int pos); + bool PointInSelection(Point pt); + bool PointInSelMargin(Point pt); + void LineSelection(int lineCurrent_, int lineAnchor_); + void DwellEnd(bool mouseMoved); + void MouseLeave(); + virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt); + void ButtonMove(Point pt); + void ButtonUp(Point pt, unsigned int curTime, bool ctrl); + + void Tick(); + bool Idle(); + virtual void SetTicking(bool on) = 0; + virtual bool SetIdle(bool) { return false; } + virtual void SetMouseCapture(bool on) = 0; + virtual bool HaveMouseCapture() = 0; + void SetFocusState(bool focusState); + + int PositionAfterArea(PRectangle rcArea); + void StyleToPositionInView(Position pos); + void IdleStyling(); + virtual void QueueStyling(int upTo); + + virtual bool PaintContains(PRectangle rc); + bool PaintContainsMargin(); + void CheckForChangeOutsidePaint(Range r); + void SetBraceHighlight(Position pos0, Position pos1, int matchStyle); + + void SetAnnotationHeights(int start, int end); + void SetDocPointer(Document *document); + + void SetAnnotationVisible(int visible); + + void Expand(int &line, bool doExpand); + void ToggleContraction(int line); + void EnsureLineVisible(int lineDoc, bool enforcePolicy); + int GetTag(char *tagValue, int tagNumber); + int ReplaceTarget(bool replacePatterns, const char *text, int length=-1); + + bool PositionIsHotspot(int position); + bool PointIsHotspot(Point pt); + void SetHotSpotRange(Point *pt); + void GetHotSpotRange(int& hsStart, int& hsEnd); + + int CodePage() const; + virtual bool ValidCodePage(int /* codePage */) const { return true; } + int WrapCount(int line); + void AddStyledText(char *buffer, int appendLength); + + virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) = 0; + void StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam); + sptr_t StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam); + + static const char *StringFromEOLMode(int eolMode); + + static sptr_t StringResult(sptr_t lParam, const char *val); + +public: + // Public so the COM thunks can access it. + bool IsUnicodeMode() const; + // Public so scintilla_send_message can use it. + virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam); + // Public so scintilla_set_id can use it. + int ctrlID; + // Public so COM methods for drag and drop can set it. + int errorStatus; + friend class AutoSurface; + friend class SelectionLineIterator; +}; + +/** + * A smart pointer class to ensure Surfaces are set up and deleted correctly. + */ +class AutoSurface { +private: + Surface *surf; +public: + AutoSurface(Editor *ed) : surf(0) { + if (ed->wMain.GetID()) { + surf = Surface::Allocate(); + if (surf) { + surf->Init(ed->wMain.GetID()); + surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage()); + surf->SetDBCSMode(ed->CodePage()); + } + } + } + AutoSurface(SurfaceID sid, Editor *ed) : surf(0) { + if (ed->wMain.GetID()) { + surf = Surface::Allocate(); + if (surf) { + surf->Init(sid, ed->wMain.GetID()); + surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage()); + surf->SetDBCSMode(ed->CodePage()); + } + } + } + ~AutoSurface() { + delete surf; + } + Surface *operator->() const { + return surf; + } + operator Surface *() const { + return surf; + } +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/ExternalLexer.cxx b/sdk/wxscintilla/src/scintilla/src/ExternalLexer.cxx new file mode 100644 index 0000000..0f17afb --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/ExternalLexer.cxx @@ -0,0 +1,262 @@ +// Scintilla source code edit control +/** @file ExternalLexer.cxx + ** Support external lexers in DLLs. + **/ +// Copyright 2001 Simon Steele , portions copyright Neil Hodgson. +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include + +#include "Platform.h" + +#include "Scintilla.h" + +#include "SciLexer.h" +#include "PropSet.h" +#include "Accessor.h" +#include "DocumentAccessor.h" +#include "KeyWords.h" +#include "ExternalLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +LexerManager *LexerManager::theInstance = NULL; + +//------------------------------------------ +// +// ExternalLexerModule +// +//------------------------------------------ + +char **WordListsToStrings(WordList *val[]) { + int dim = 0; + while (val[dim]) + dim++; + char **wls = new char * [dim + 1]; + for (int i = 0;i < dim;i++) { + std::string words; + words = ""; + for (int n = 0; n < val[i]->len; n++) { + words += val[i]->words[n]; + if (n != val[i]->len - 1) + words += " "; + } + wls[i] = new char[words.length() + 1]; + strcpy(wls[i], words.c_str()); + } + wls[dim] = 0; + return wls; +} + +void DeleteWLStrings(char *strs[]) { + int dim = 0; + while (strs[dim]) { + delete strs[dim]; + dim++; + } + delete [] strs; +} + +void ExternalLexerModule::Lex(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const { + if (!fneLexer) + return ; + + char **kwds = WordListsToStrings(keywordlists); + char *ps = styler.GetProperties(); + + // The accessor passed in is always a DocumentAccessor so this cast and the subsequent + // access will work. Can not use the stricter dynamic_cast as that requires RTTI. + DocumentAccessor &da = static_cast(styler); + WindowID wID = da.GetWindow(); + + fneLexer(externalLanguage, startPos, lengthDoc, initStyle, kwds, wID, ps); + + delete ps; + DeleteWLStrings(kwds); +} + +void ExternalLexerModule::Fold(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const { + if (!fneFolder) + return ; + + char **kwds = WordListsToStrings(keywordlists); + char *ps = styler.GetProperties(); + + // The accessor passed in is always a DocumentAccessor so this cast and the subsequent + // access will work. Can not use the stricter dynamic_cast as that requires RTTI. + DocumentAccessor &da = static_cast(styler); + WindowID wID = da.GetWindow(); + + fneFolder(externalLanguage, startPos, lengthDoc, initStyle, kwds, wID, ps); + + delete ps; + DeleteWLStrings(kwds); +} + +void ExternalLexerModule::SetExternal(ExtLexerFunction fLexer, ExtFoldFunction fFolder, int index) { + fneLexer = fLexer; + fneFolder = fFolder; + externalLanguage = index; +} + +//------------------------------------------ +// +// LexerLibrary +// +//------------------------------------------ + +LexerLibrary::LexerLibrary(const char* ModuleName) { + // Initialise some members... + first = NULL; + last = NULL; + + // Load the DLL + lib = DynamicLibrary::Load(ModuleName); + if (lib->IsValid()) { + m_sModuleName = ModuleName; + //Cannot use reinterpret_cast because: ANSI C++ forbids casting between pointers to functions and objects + GetLexerCountFn GetLexerCount = (GetLexerCountFn)(sptr_t)lib->FindFunction("GetLexerCount"); + + if (GetLexerCount) { + ExternalLexerModule *lex; + LexerMinder *lm; + + // Find functions in the DLL + GetLexerNameFn GetLexerName = (GetLexerNameFn)(sptr_t)lib->FindFunction("GetLexerName"); + ExtLexerFunction Lexer = (ExtLexerFunction)(sptr_t)lib->FindFunction("Lex"); + ExtFoldFunction Folder = (ExtFoldFunction)(sptr_t)lib->FindFunction("Fold"); + + // Assign a buffer for the lexer name. + char lexname[100]; + strcpy(lexname, ""); + + int nl = GetLexerCount(); + + for (int i = 0; i < nl; i++) { + GetLexerName(i, lexname, 100); + lex = new ExternalLexerModule(SCLEX_AUTOMATIC, NULL, lexname, NULL); + + // Create a LexerMinder so we don't leak the ExternalLexerModule... + lm = new LexerMinder; + lm->self = lex; + lm->next = NULL; + if (first != NULL) { + last->next = lm; + last = lm; + } else { + first = lm; + last = lm; + } + + // The external lexer needs to know how to call into its DLL to + // do its lexing and folding, we tell it here. Folder may be null. + lex->SetExternal(Lexer, Folder, i); + } + } + } + next = NULL; +} + +LexerLibrary::~LexerLibrary() { + Release(); + delete lib; +} + +void LexerLibrary::Release() { + //TODO maintain a list of lexers created, and delete them! + LexerMinder *lm; + LexerMinder *lmNext; + lm = first; + while (NULL != lm) { + lmNext = lm->next; + delete lm->self; + delete lm; + lm = lmNext; + } + + first = NULL; + last = NULL; +} + +//------------------------------------------ +// +// LexerManager +// +//------------------------------------------ + +/// Return the single LexerManager instance... +LexerManager *LexerManager::GetInstance() { + if(!theInstance) + theInstance = new LexerManager; + return theInstance; +} + +/// Delete any LexerManager instance... +void LexerManager::DeleteInstance() { + delete theInstance; + theInstance = NULL; + } + +/// protected constructor - this is a singleton... +LexerManager::LexerManager() { + first = NULL; + last = NULL; +} + +LexerManager::~LexerManager() { + Clear(); +} + +void LexerManager::Load(const char *path) { + LoadLexerLibrary(path); +} + +void LexerManager::LoadLexerLibrary(const char *module) { + for (LexerLibrary *ll = first; ll; ll= ll->next) { + if (strcmp(ll->m_sModuleName.c_str(), module) == 0) + return; + } + LexerLibrary *lib = new LexerLibrary(module); + if (NULL != first) { + last->next = lib; + last = lib; + } else { + first = lib; + last = lib; + } +} + +void LexerManager::Clear() { + if (NULL != first) { + LexerLibrary *cur = first; + LexerLibrary *next; + while (cur) { + next = cur->next; + delete cur; + cur = next; + } + first = NULL; + last = NULL; + } +} + +//------------------------------------------ +// +// LexerManager +// +//------------------------------------------ + +LMMinder::~LMMinder() { + LexerManager::DeleteInstance(); +} + +LMMinder minder; diff --git a/sdk/wxscintilla/src/scintilla/src/ExternalLexer.h b/sdk/wxscintilla/src/scintilla/src/ExternalLexer.h new file mode 100644 index 0000000..c4bfbf4 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/ExternalLexer.h @@ -0,0 +1,104 @@ +// Scintilla source code edit control +/** @file ExternalLexer.h + ** Support external lexers in DLLs. + **/ +// Copyright 2001 Simon Steele , portions copyright Neil Hodgson. +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef EXTERNALLEXER_H +#define EXTERNALLEXER_H + +#if PLAT_WIN +#define EXT_LEXER_DECL __stdcall +#else +#define EXT_LEXER_DECL +#endif + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +// External Lexer function definitions... +typedef void (EXT_LEXER_DECL *ExtLexerFunction)(unsigned int lexer, unsigned int startPos, int length, int initStyle, + char *words[], WindowID window, char *props); +typedef void (EXT_LEXER_DECL *ExtFoldFunction)(unsigned int lexer, unsigned int startPos, int length, int initStyle, + char *words[], WindowID window, char *props); +typedef void* (EXT_LEXER_DECL *GetLexerFunction)(unsigned int Index); +typedef int (EXT_LEXER_DECL *GetLexerCountFn)(); +typedef void (EXT_LEXER_DECL *GetLexerNameFn)(unsigned int Index, char *name, int buflength); + +//class DynamicLibrary; + +/// Sub-class of LexerModule to use an external lexer. +class ExternalLexerModule : protected LexerModule { +protected: + ExtLexerFunction fneLexer; + ExtFoldFunction fneFolder; + int externalLanguage; + char name[100]; +public: + ExternalLexerModule(int language_, LexerFunction fnLexer_, + const char *languageName_=0, LexerFunction fnFolder_=0) : LexerModule(language_, fnLexer_, 0, fnFolder_){ + strncpy(name, languageName_, sizeof(name)); + name[sizeof(name)-1] = '\0'; + languageName = name; + } + virtual void Lex(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const; + virtual void Fold(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const; + virtual void SetExternal(ExtLexerFunction fLexer, ExtFoldFunction fFolder, int index); +}; + +/// LexerMinder points to an ExternalLexerModule - so we don't leak them. +class LexerMinder { +public: + ExternalLexerModule *self; + LexerMinder *next; +}; + +/// LexerLibrary exists for every External Lexer DLL, contains LexerMinders. +class LexerLibrary { + DynamicLibrary *lib; + LexerMinder *first; + LexerMinder *last; + +public: + LexerLibrary(const char* ModuleName); + ~LexerLibrary(); + void Release(); + + LexerLibrary *next; + std::string m_sModuleName; +}; + +/// LexerManager manages external lexers, contains LexerLibrarys. +class LexerManager { +public: + ~LexerManager(); + + static LexerManager *GetInstance(); + static void DeleteInstance(); + + void Load(const char* path); + void Clear(); + +private: + LexerManager(); + static LexerManager *theInstance; + + void LoadLexerLibrary(const char* module); + LexerLibrary *first; + LexerLibrary *last; +}; + +class LMMinder { +public: + ~LMMinder(); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/FontQuality.h b/sdk/wxscintilla/src/scintilla/src/FontQuality.h new file mode 100644 index 0000000..2c8d548 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/FontQuality.h @@ -0,0 +1,12 @@ +// Scintilla source code edit control +/** @file FontQuality.h + ** Definitions to control font anti-aliasing. + **/ +// Copyright 1998-2009 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#define SC_EFF_QUALITY_MASK 0xF +#define SC_EFF_QUALITY_DEFAULT 0 +#define SC_EFF_QUALITY_NON_ANTIALIASED 1 +#define SC_EFF_QUALITY_ANTIALIASED 2 +#define SC_EFF_QUALITY_LCD_OPTIMIZED 3 diff --git a/sdk/wxscintilla/src/scintilla/src/Indicator.cxx b/sdk/wxscintilla/src/scintilla/src/Indicator.cxx new file mode 100644 index 0000000..da95312 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Indicator.cxx @@ -0,0 +1,81 @@ +// Scintilla source code edit control +/** @file Indicator.cxx + ** Defines the style of indicators which are text decorations such as underlining. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include "Platform.h" + +#include "Scintilla.h" +#include "Indicator.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine) { + surface->PenColour(fore.allocated); + int ymid = (rc.bottom + rc.top) / 2; + if (style == INDIC_SQUIGGLE) { + surface->MoveTo(rc.left, rc.top); + int x = rc.left + 2; + int y = 2; + while (x < rc.right) { + surface->LineTo(x, rc.top + y); + x += 2; + y = 2 - y; + } + surface->LineTo(rc.right, rc.top + y); // Finish the line + } else if (style == INDIC_TT) { + surface->MoveTo(rc.left, ymid); + int x = rc.left + 5; + while (x < rc.right) { + surface->LineTo(x, ymid); + surface->MoveTo(x-3, ymid); + surface->LineTo(x-3, ymid+2); + x++; + surface->MoveTo(x, ymid); + x += 5; + } + surface->LineTo(rc.right, ymid); // Finish the line + if (x - 3 <= rc.right) { + surface->MoveTo(x-3, ymid); + surface->LineTo(x-3, ymid+2); + } + } else if (style == INDIC_DIAGONAL) { + int x = rc.left; + while (x < rc.right) { + surface->MoveTo(x, rc.top+2); + int endX = x+3; + int endY = rc.top - 1; + if (endX > rc.right) { + endY += endX - rc.right; + endX = rc.right; + } + surface->LineTo(endX, endY); + x += 4; + } + } else if (style == INDIC_STRIKE) { + surface->MoveTo(rc.left, rc.top - 4); + surface->LineTo(rc.right, rc.top - 4); + } else if (style == INDIC_HIDDEN) { + // Draw nothing + } else if (style == INDIC_BOX) { + surface->MoveTo(rc.left, ymid+1); + surface->LineTo(rc.right, ymid+1); + surface->LineTo(rc.right, rcLine.top+1); + surface->LineTo(rc.left, rcLine.top+1); + surface->LineTo(rc.left, ymid+1); + } else if (style == INDIC_ROUNDBOX) { + PRectangle rcBox = rcLine; + rcBox.top = rcLine.top + 1; + rcBox.left = rc.left; + rcBox.right = rc.right; + surface->AlphaRectangle(rcBox, 1, fore.allocated, fillAlpha, fore.allocated, 50, 0); + } else { // Either INDIC_PLAIN or unknown + surface->MoveTo(rc.left, ymid); + surface->LineTo(rc.right, ymid); + } +} + diff --git a/sdk/wxscintilla/src/scintilla/src/Indicator.h b/sdk/wxscintilla/src/scintilla/src/Indicator.h new file mode 100644 index 0000000..42b56f0 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/Indicator.h @@ -0,0 +1,32 @@ +// Scintilla source code edit control +/** @file Indicator.h + ** Defines the style of indicators which are text decorations such as underlining. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef INDICATOR_H +#define INDICATOR_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +/** + */ +class Indicator { +public: + int style; + bool under; + ColourPair fore; + int fillAlpha; + Indicator() : style(INDIC_PLAIN), under(false), fore(ColourDesired(0,0,0)), fillAlpha(30) { + } + void Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine); +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/KeyMap.cxx b/sdk/wxscintilla/src/scintilla/src/KeyMap.cxx new file mode 100644 index 0000000..bab5e27 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/KeyMap.cxx @@ -0,0 +1,152 @@ +// Scintilla source code edit control +/** @file KeyMap.cxx + ** Defines a mapping between keystrokes and commands. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include "Platform.h" + +#include "Scintilla.h" + +#include "KeyMap.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +KeyMap::KeyMap() : kmap(0), len(0), alloc(0) { + for (int i = 0; MapDefault[i].key; i++) { + AssignCmdKey(MapDefault[i].key, + MapDefault[i].modifiers, + MapDefault[i].msg); + } +} + +KeyMap::~KeyMap() { + Clear(); +} + +void KeyMap::Clear() { + delete []kmap; + kmap = 0; + len = 0; + alloc = 0; +} + +void KeyMap::AssignCmdKey(int key, int modifiers, unsigned int msg) { + if ((len+1) >= alloc) { + KeyToCommand *ktcNew = new KeyToCommand[alloc + 5]; + if (!ktcNew) + return; + for (int k = 0; k < len; k++) + ktcNew[k] = kmap[k]; + alloc += 5; + delete []kmap; + kmap = ktcNew; + } + for (int keyIndex = 0; keyIndex < len; keyIndex++) { + if ((key == kmap[keyIndex].key) && (modifiers == kmap[keyIndex].modifiers)) { + kmap[keyIndex].msg = msg; + return; + } + } + kmap[len].key = key; + kmap[len].modifiers = modifiers; + kmap[len].msg = msg; + len++; +} + +unsigned int KeyMap::Find(int key, int modifiers) { + for (int i = 0; i < len; i++) { + if ((key == kmap[i].key) && (modifiers == kmap[i].modifiers)) { + return kmap[i].msg; + } + } + return 0; +} + +const KeyToCommand KeyMap::MapDefault[] = { + {SCK_DOWN, SCI_NORM, SCI_LINEDOWN}, + {SCK_DOWN, SCI_SHIFT, SCI_LINEDOWNEXTEND}, + {SCK_DOWN, SCI_CTRL, SCI_LINESCROLLDOWN}, + {SCK_DOWN, SCI_ASHIFT, SCI_LINEDOWNRECTEXTEND}, + {SCK_UP, SCI_NORM, SCI_LINEUP}, + {SCK_UP, SCI_SHIFT, SCI_LINEUPEXTEND}, + {SCK_UP, SCI_CTRL, SCI_LINESCROLLUP}, + {SCK_UP, SCI_ASHIFT, SCI_LINEUPRECTEXTEND}, + {'[', SCI_CTRL, SCI_PARAUP}, + {'[', SCI_CSHIFT, SCI_PARAUPEXTEND}, + {']', SCI_CTRL, SCI_PARADOWN}, + {']', SCI_CSHIFT, SCI_PARADOWNEXTEND}, + {SCK_LEFT, SCI_NORM, SCI_CHARLEFT}, + {SCK_LEFT, SCI_SHIFT, SCI_CHARLEFTEXTEND}, + {SCK_LEFT, SCI_CTRL, SCI_WORDLEFT}, + {SCK_LEFT, SCI_CSHIFT, SCI_WORDLEFTEXTEND}, + {SCK_LEFT, SCI_ASHIFT, SCI_CHARLEFTRECTEXTEND}, + {SCK_RIGHT, SCI_NORM, SCI_CHARRIGHT}, + {SCK_RIGHT, SCI_SHIFT, SCI_CHARRIGHTEXTEND}, + {SCK_RIGHT, SCI_CTRL, SCI_WORDRIGHT}, + {SCK_RIGHT, SCI_CSHIFT, SCI_WORDRIGHTEXTEND}, + {SCK_RIGHT, SCI_ASHIFT, SCI_CHARRIGHTRECTEXTEND}, + {'/', SCI_CTRL, SCI_WORDPARTLEFT}, + {'/', SCI_CSHIFT, SCI_WORDPARTLEFTEXTEND}, + {'\\', SCI_CTRL, SCI_WORDPARTRIGHT}, + {'\\', SCI_CSHIFT, SCI_WORDPARTRIGHTEXTEND}, + {SCK_HOME, SCI_NORM, SCI_VCHOME}, + {SCK_HOME, SCI_SHIFT, SCI_VCHOMEEXTEND}, + {SCK_HOME, SCI_CTRL, SCI_DOCUMENTSTART}, + {SCK_HOME, SCI_CSHIFT, SCI_DOCUMENTSTARTEXTEND}, + {SCK_HOME, SCI_ALT, SCI_HOMEDISPLAY}, +// {SCK_HOME, SCI_ASHIFT, SCI_HOMEDISPLAYEXTEND}, + {SCK_HOME, SCI_ASHIFT, SCI_VCHOMERECTEXTEND}, + {SCK_END, SCI_NORM, SCI_LINEEND}, + {SCK_END, SCI_SHIFT, SCI_LINEENDEXTEND}, + {SCK_END, SCI_CTRL, SCI_DOCUMENTEND}, + {SCK_END, SCI_CSHIFT, SCI_DOCUMENTENDEXTEND}, + {SCK_END, SCI_ALT, SCI_LINEENDDISPLAY}, +// {SCK_END, SCI_ASHIFT, SCI_LINEENDDISPLAYEXTEND}, + {SCK_END, SCI_ASHIFT, SCI_LINEENDRECTEXTEND}, + {SCK_PRIOR, SCI_NORM, SCI_PAGEUP}, + {SCK_PRIOR, SCI_SHIFT, SCI_PAGEUPEXTEND}, + {SCK_PRIOR, SCI_ASHIFT, SCI_PAGEUPRECTEXTEND}, + {SCK_NEXT, SCI_NORM, SCI_PAGEDOWN}, + {SCK_NEXT, SCI_SHIFT, SCI_PAGEDOWNEXTEND}, + {SCK_NEXT, SCI_ASHIFT, SCI_PAGEDOWNRECTEXTEND}, + {SCK_DELETE, SCI_NORM, SCI_CLEAR}, + {SCK_DELETE, SCI_SHIFT, SCI_CUT}, + {SCK_DELETE, SCI_CTRL, SCI_DELWORDRIGHT}, + {SCK_DELETE, SCI_CSHIFT, SCI_DELLINERIGHT}, + {SCK_INSERT, SCI_NORM, SCI_EDITTOGGLEOVERTYPE}, + {SCK_INSERT, SCI_SHIFT, SCI_PASTE}, + {SCK_INSERT, SCI_CTRL, SCI_COPY}, + {SCK_ESCAPE, SCI_NORM, SCI_CANCEL}, + {SCK_BACK, SCI_NORM, SCI_DELETEBACK}, + {SCK_BACK, SCI_SHIFT, SCI_DELETEBACK}, + {SCK_BACK, SCI_CTRL, SCI_DELWORDLEFT}, + {SCK_BACK, SCI_ALT, SCI_UNDO}, + {SCK_BACK, SCI_CSHIFT, SCI_DELLINELEFT}, + {'Z', SCI_CTRL, SCI_UNDO}, + {'Y', SCI_CTRL, SCI_REDO}, + {'X', SCI_CTRL, SCI_CUT}, + {'C', SCI_CTRL, SCI_COPY}, + {'V', SCI_CTRL, SCI_PASTE}, + {'A', SCI_CTRL, SCI_SELECTALL}, + {SCK_TAB, SCI_NORM, SCI_TAB}, + {SCK_TAB, SCI_SHIFT, SCI_BACKTAB}, + {SCK_RETURN, SCI_NORM, SCI_NEWLINE}, + {SCK_RETURN, SCI_SHIFT, SCI_NEWLINE}, + {SCK_ADD, SCI_CTRL, SCI_ZOOMIN}, + {SCK_SUBTRACT, SCI_CTRL, SCI_ZOOMOUT}, + {SCK_DIVIDE, SCI_CTRL, SCI_SETZOOM}, + //'L', SCI_CTRL, SCI_FORMFEED, + {'L', SCI_CTRL, SCI_LINECUT}, + {'L', SCI_CSHIFT, SCI_LINEDELETE}, + {'T', SCI_CSHIFT, SCI_LINECOPY}, + {'T', SCI_CTRL, SCI_LINETRANSPOSE}, + {'D', SCI_CTRL, SCI_SELECTIONDUPLICATE}, + {'U', SCI_CTRL, SCI_LOWERCASE}, + {'U', SCI_CSHIFT, SCI_UPPERCASE}, + {0,0,0}, +}; + diff --git a/sdk/wxscintilla/src/scintilla/src/KeyMap.h b/sdk/wxscintilla/src/scintilla/src/KeyMap.h new file mode 100644 index 0000000..c1b1a10 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/KeyMap.h @@ -0,0 +1,51 @@ +// Scintilla source code edit control +/** @file KeyMap.h + ** Defines a mapping between keystrokes and commands. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#ifndef KEYTOCOMMAND_H +#define KEYTOCOMMAND_H + +#ifdef SCI_NAMESPACE +namespace Scintilla { +#endif + +#define SCI_NORM 0 +#define SCI_SHIFT SCMOD_SHIFT +#define SCI_CTRL SCMOD_CTRL +#define SCI_ALT SCMOD_ALT +#define SCI_CSHIFT (SCI_CTRL | SCI_SHIFT) +#define SCI_ASHIFT (SCI_ALT | SCI_SHIFT) + +/** + */ +class KeyToCommand { +public: + int key; + int modifiers; + unsigned int msg; +}; + +/** + */ +class KeyMap { + KeyToCommand *kmap; + int len; + int alloc; + static const KeyToCommand MapDefault[]; + +public: + KeyMap(); + ~KeyMap(); + void Clear(); + void AssignCmdKey(int key, int modifiers, unsigned int msg); + unsigned int Find(int key, int modifiers); // 0 returned on failure +}; + +#ifdef SCI_NAMESPACE +} +#endif + +#endif diff --git a/sdk/wxscintilla/src/scintilla/src/KeyWords.cxx b/sdk/wxscintilla/src/scintilla/src/KeyWords.cxx new file mode 100644 index 0000000..600ee55 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/KeyWords.cxx @@ -0,0 +1,441 @@ +// Scintilla source code edit control +/** @file KeyWords.cxx + ** Colourise for particular languages. + **/ +// Copyright 1998-2002 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +/** + * Creates an array that points into each word in the string and puts \0 terminators + * after each word. + */ +static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = false) { + int prev = '\n'; + int words = 0; + // For rapid determination of whether a character is a separator, build + // a look up table. + bool wordSeparator[256]; + for (int i=0;i<256; i++) { + wordSeparator[i] = false; + } + wordSeparator['\r'] = true; + wordSeparator['\n'] = true; + if (!onlyLineEnds) { + wordSeparator[' '] = true; + wordSeparator['\t'] = true; + } + for (int j = 0; wordlist[j]; j++) { + int curr = static_cast(wordlist[j]); + if (!wordSeparator[curr] && wordSeparator[prev]) + words++; + prev = curr; + } + char **keywords = new char *[words + 1]; + if (keywords) { + words = 0; + prev = '\0'; + size_t slen = strlen(wordlist); + for (size_t k = 0; k < slen; k++) { + if (!wordSeparator[static_cast(wordlist[k])]) { + if (!prev) { + keywords[words] = &wordlist[k]; + words++; + } + } else { + wordlist[k] = '\0'; + } + prev = wordlist[k]; + } + keywords[words] = &wordlist[slen]; + *len = words; + } else { + *len = 0; + } + return keywords; +} + +void WordList::Clear() { + if (words) { + delete []list; + delete []words; + } + words = 0; + list = 0; + len = 0; + sorted = false; +} + +void WordList::Set(const char *s) { + list = new char[strlen(s) + 1]; + strcpy(list, s); + sorted = false; + words = ArrayFromWordList(list, &len, onlyLineEnds); +} + +extern "C" int cmpString(const void *a1, const void *a2) { + // Can't work out the correct incantation to use modern casts here + return strcmp(*(char**)(a1), *(char**)(a2)); +} + +static void SortWordList(char **words, unsigned int len) { + qsort(reinterpret_cast(words), len, sizeof(*words), + cmpString); +} + +bool WordList::InList(const char *s) { + if (0 == words) + return false; + if (!sorted) { + sorted = true; + SortWordList(words, len); + for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++) + starts[k] = -1; + for (int l = len - 1; l >= 0; l--) { + unsigned char indexChar = words[l][0]; + starts[indexChar] = l; + } + } + unsigned char firstChar = s[0]; + int j = starts[firstChar]; + if (j >= 0) { + while ((unsigned char)words[j][0] == firstChar) { + if (s[1] == words[j][1]) { + const char *a = words[j] + 1; + const char *b = s + 1; + while (*a && *a == *b) { + a++; + b++; + } + if (!*a && !*b) + return true; + } + j++; + } + } + j = starts['^']; + if (j >= 0) { + while (words[j][0] == '^') { + const char *a = words[j] + 1; + const char *b = s; + while (*a && *a == *b) { + a++; + b++; + } + if (!*a) + return true; + j++; + } + } + return false; +} + +/** similar to InList, but word s can be a substring of keyword. + * eg. the keyword define is defined as def~ine. This means the word must start + * with def to be a keyword, but also defi, defin and define are valid. + * The marker is ~ in this case. + */ +bool WordList::InListAbbreviated(const char *s, const char marker) { + if (0 == words) + return false; + if (!sorted) { + sorted = true; + SortWordList(words, len); + for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++) + starts[k] = -1; + for (int l = len - 1; l >= 0; l--) { + unsigned char indexChar = words[l][0]; + starts[indexChar] = l; + } + } + unsigned char firstChar = s[0]; + int j = starts[firstChar]; + if (j >= 0) { + while (words[j][0] == firstChar) { + bool isSubword = false; + int start = 1; + if (words[j][1] == marker) { + isSubword = true; + start++; + } + if (s[1] == words[j][start]) { + const char *a = words[j] + start; + const char *b = s + 1; + while (*a && *a == *b) { + a++; + if (*a == marker) { + isSubword = true; + a++; + } + b++; + } + if ((!*a || isSubword) && !*b) + return true; + } + j++; + } + } + j = starts['^']; + if (j >= 0) { + while (words[j][0] == '^') { + const char *a = words[j] + 1; + const char *b = s; + while (*a && *a == *b) { + a++; + b++; + } + if (!*a) + return true; + j++; + } + } + return false; +} + +const LexerModule *LexerModule::base = 0; +int LexerModule::nextLanguage = SCLEX_AUTOMATIC+1; + +LexerModule::LexerModule(int language_, + LexerFunction fnLexer_, + const char *languageName_, + LexerFunction fnFolder_, + const char * const wordListDescriptions_[], + int styleBits_) : + language(language_), + fnLexer(fnLexer_), + fnFolder(fnFolder_), + wordListDescriptions(wordListDescriptions_), + styleBits(styleBits_), + languageName(languageName_) { + next = base; + base = this; + if (language == SCLEX_AUTOMATIC) { + language = nextLanguage; + nextLanguage++; + } +} + +int LexerModule::GetNumWordLists() const { + if (wordListDescriptions == NULL) { + return -1; + } else { + int numWordLists = 0; + + while (wordListDescriptions[numWordLists]) { + ++numWordLists; + } + + return numWordLists; + } +} + +const char *LexerModule::GetWordListDescription(int index) const { + static const char *emptyStr = ""; + + PLATFORM_ASSERT(index < GetNumWordLists()); + if (index >= GetNumWordLists()) { + return emptyStr; + } else { + return wordListDescriptions[index]; + } +} + +int LexerModule::GetStyleBitsNeeded() const { + return styleBits; +} + +const LexerModule *LexerModule::Find(int language) { + const LexerModule *lm = base; + while (lm) { + if (lm->language == language) { + return lm; + } + lm = lm->next; + } + return 0; +} + +const LexerModule *LexerModule::Find(const char *languageName) { + if (languageName) { + const LexerModule *lm = base; + while (lm) { + if (lm->languageName && 0 == strcmp(lm->languageName, languageName)) { + return lm; + } + lm = lm->next; + } + } + return 0; +} + +void LexerModule::Lex(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const { + if (fnLexer) + fnLexer(startPos, lengthDoc, initStyle, keywordlists, styler); +} + +void LexerModule::Fold(unsigned int startPos, int lengthDoc, int initStyle, + WordList *keywordlists[], Accessor &styler) const { + if (fnFolder) { + int lineCurrent = styler.GetLine(startPos); + // Move back one line in case deletion wrecked current line fold state + if (lineCurrent > 0) { + lineCurrent--; + int newStartPos = styler.LineStart(lineCurrent); + lengthDoc += startPos - newStartPos; + startPos = newStartPos; + initStyle = 0; + if (startPos > 0) { + initStyle = styler.StyleAt(startPos - 1); + } + } + fnFolder(startPos, lengthDoc, initStyle, keywordlists, styler); + } +} + +// Alternative historical name for Scintilla_LinkLexers +int wxForceScintillaLexers(void) { + return Scintilla_LinkLexers(); +} + +// To add or remove a lexer, add or remove its file and run LexGen.py. + +// Force a reference to all of the Scintilla lexers so that the linker will +// not remove the code of the lexers. +int Scintilla_LinkLexers() { + static int forcer = 0; + +// Shorten the code that declares a lexer and ensures it is linked in by calling a method. +#define LINK_LEXER(lexer) extern LexerModule lexer; forcer += lexer.GetLanguage(); + +//++Autogenerated -- run src/LexGen.py to regenerate +//**\(\tLINK_LEXER(\*);\n\) + LINK_LEXER(lmAbaqus); + LINK_LEXER(lmAda); + LINK_LEXER(lmAns1); + LINK_LEXER(lmAPDL); + LINK_LEXER(lmAsm); + LINK_LEXER(lmASY); + LINK_LEXER(lmAU3); + LINK_LEXER(lmAVE); + LINK_LEXER(lmBaan); + LINK_LEXER(lmBash); + LINK_LEXER(lmBatch); + LINK_LEXER(lmBlitzBasic); + LINK_LEXER(lmBullant); + LINK_LEXER(lmCaml); + LINK_LEXER(lmClw); + LINK_LEXER(lmClwNoCase); + LINK_LEXER(lmCmake); + LINK_LEXER(lmCOBOL); + LINK_LEXER(lmConf); + LINK_LEXER(lmCPP); + LINK_LEXER(lmCPPNoCase); + LINK_LEXER(lmCsound); + LINK_LEXER(lmCss); + LINK_LEXER(lmD); + LINK_LEXER(lmDiff); + LINK_LEXER(lmEiffel); + LINK_LEXER(lmEiffelkw); + LINK_LEXER(lmErlang); + LINK_LEXER(lmErrorList); + LINK_LEXER(lmESCRIPT); + LINK_LEXER(lmF77); + LINK_LEXER(lmFlagShip); + LINK_LEXER(lmForth); + LINK_LEXER(lmFortran); + LINK_LEXER(lmFreeBasic); + LINK_LEXER(lmGAP); + LINK_LEXER(lmGui4Cli); + LINK_LEXER(lmHaskell); + LINK_LEXER(lmHTML); + LINK_LEXER(lmInno); + LINK_LEXER(lmKix); + LINK_LEXER(lmLatex); + LINK_LEXER(lmLISP); + LINK_LEXER(lmLot); + LINK_LEXER(lmLout); + LINK_LEXER(lmLua); + LINK_LEXER(lmMagikSF); + LINK_LEXER(lmMake); + LINK_LEXER(lmMarkdown); + LINK_LEXER(lmMatlab); + LINK_LEXER(lmMETAPOST); + LINK_LEXER(lmMMIXAL); + LINK_LEXER(lmMSSQL); + LINK_LEXER(lmMySQL); + LINK_LEXER(lmNimrod); + LINK_LEXER(lmNncrontab); + LINK_LEXER(lmNsis); + LINK_LEXER(lmNull); + LINK_LEXER(lmOctave); + LINK_LEXER(lmOpal); + LINK_LEXER(lmPascal); + LINK_LEXER(lmPB); + LINK_LEXER(lmPerl); + LINK_LEXER(lmPHPSCRIPT); + LINK_LEXER(lmPLM); + LINK_LEXER(lmPo); + LINK_LEXER(lmPOV); + LINK_LEXER(lmPowerPro); + LINK_LEXER(lmPowerShell); + LINK_LEXER(lmProgress); + LINK_LEXER(lmProps); + LINK_LEXER(lmPS); + LINK_LEXER(lmPureBasic); + LINK_LEXER(lmPython); + LINK_LEXER(lmR); + LINK_LEXER(lmREBOL); + LINK_LEXER(lmRuby); + LINK_LEXER(lmScriptol); + LINK_LEXER(lmSmalltalk); + LINK_LEXER(lmSML); + LINK_LEXER(lmSorc); + LINK_LEXER(lmSpecman); + LINK_LEXER(lmSpice); + LINK_LEXER(lmSQL); + LINK_LEXER(lmTACL); + LINK_LEXER(lmTADS3); + LINK_LEXER(lmTAL); + LINK_LEXER(lmTCL); + LINK_LEXER(lmTeX); + LINK_LEXER(lmVB); + LINK_LEXER(lmVBScript); + LINK_LEXER(lmVerilog); + LINK_LEXER(lmVHDL); + LINK_LEXER(lmXML); + LINK_LEXER(lmYAML); + +//ERAN - START + LINK_LEXER(lmGcc); + LINK_LEXER(lmFif); + LINK_LEXER(lmSvn); + LINK_LEXER(lmCppCheck); +//ERAN - END + +// EPOCH - START + LINK_LEXER(lmAltaRica); + LINK_LEXER(lmPrism); +// EPOCH - END + +//--Autogenerated -- end of automatically generated section + + return 1; +} diff --git a/sdk/wxscintilla/src/scintilla/src/LexAPDL.cxx b/sdk/wxscintilla/src/scintilla/src/LexAPDL.cxx new file mode 100644 index 0000000..a9a6c54 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAPDL.cxx @@ -0,0 +1,256 @@ +// Scintilla source code edit control +/** @file LexAPDL.cxx + ** Lexer for APDL. Based on the lexer for Assembler by The Black Horus. + ** By Hadar Raz. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80 && (isalnum(ch) || ch == '_')); +} + +static inline bool IsAnOperator(char ch) { + // '.' left out as it is used to make up numbers + if (ch == '*' || ch == '/' || ch == '-' || ch == '+' || + ch == '(' || ch == ')' || ch == '=' || ch == '^' || + ch == '[' || ch == ']' || ch == '<' || ch == '&' || + ch == '>' || ch == ',' || ch == '|' || ch == '~' || + ch == '$' || ch == ':' || ch == '%') + return true; + return false; +} + +static void ColouriseAPDLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + + int stringStart = ' '; + + WordList &processors = *keywordlists[0]; + WordList &commands = *keywordlists[1]; + WordList &slashcommands = *keywordlists[2]; + WordList &starcommands = *keywordlists[3]; + WordList &arguments = *keywordlists[4]; + WordList &functions = *keywordlists[5]; + + // Do not leak onto next line + initStyle = SCE_APDL_DEFAULT; + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + // Determine if the current state should terminate. + if (sc.state == SCE_APDL_NUMBER) { + if (!(IsADigit(sc.ch) || sc.ch == '.' || (sc.ch == 'e' || sc.ch == 'E') || + ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E')))) { + sc.SetState(SCE_APDL_DEFAULT); + } + } else if (sc.state == SCE_APDL_COMMENT) { + if (sc.atLineEnd) { + sc.SetState(SCE_APDL_DEFAULT); + } + } else if (sc.state == SCE_APDL_COMMENTBLOCK) { + if (sc.atLineEnd) { + if (sc.ch == '\r') { + sc.Forward(); + } + sc.ForwardSetState(SCE_APDL_DEFAULT); + } + } else if (sc.state == SCE_APDL_STRING) { + if (sc.atLineEnd) { + sc.SetState(SCE_APDL_DEFAULT); + } else if ((sc.ch == '\'' && stringStart == '\'') || (sc.ch == '\"' && stringStart == '\"')) { + sc.ForwardSetState(SCE_APDL_DEFAULT); + } + } else if (sc.state == SCE_APDL_WORD) { + if (!IsAWordChar(sc.ch)) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + if (processors.InList(s)) { + sc.ChangeState(SCE_APDL_PROCESSOR); + } else if (slashcommands.InList(s)) { + sc.ChangeState(SCE_APDL_SLASHCOMMAND); + } else if (starcommands.InList(s)) { + sc.ChangeState(SCE_APDL_STARCOMMAND); + } else if (commands.InList(s)) { + sc.ChangeState(SCE_APDL_COMMAND); + } else if (arguments.InList(s)) { + sc.ChangeState(SCE_APDL_ARGUMENT); + } else if (functions.InList(s)) { + sc.ChangeState(SCE_APDL_FUNCTION); + } + sc.SetState(SCE_APDL_DEFAULT); + } + } else if (sc.state == SCE_APDL_OPERATOR) { + if (!IsAnOperator(static_cast(sc.ch))) { + sc.SetState(SCE_APDL_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_APDL_DEFAULT) { + if (sc.ch == '!' && sc.chNext == '!') { + sc.SetState(SCE_APDL_COMMENTBLOCK); + } else if (sc.ch == '!') { + sc.SetState(SCE_APDL_COMMENT); + } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_APDL_NUMBER); + } else if (sc.ch == '\'' || sc.ch == '\"') { + sc.SetState(SCE_APDL_STRING); + stringStart = sc.ch; + } else if (IsAWordChar(sc.ch) || ((sc.ch == '*' || sc.ch == '/') && !isgraph(sc.chPrev))) { + sc.SetState(SCE_APDL_WORD); + } else if (IsAnOperator(static_cast(sc.ch))) { + sc.SetState(SCE_APDL_OPERATOR); + } + } + } + sc.Complete(); +} + +//------------------------------------------------------------------------------ +// 06-27-07 Sergio Lucato +// - Included code folding for Ansys APDL lexer +// - Copyied from LexBasic.cxx and modified for APDL +//------------------------------------------------------------------------------ + +/* Bits: + * 1 - whitespace + * 2 - operator + * 4 - identifier + * 8 - decimal digit + * 16 - hex digit + * 32 - bin digit + */ +static int character_classification[128] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, 2, 10, 6, + 60, 60, 28, 28, 28, 28, 28, 28, 28, 28, 2, 2, 2, 2, 2, 2, + 2, 20, 20, 20, 20, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 4, + 2, 20, 20, 20, 20, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0 +}; + +static bool IsSpace(int c) { + return c < 128 && (character_classification[c] & 1); +} + +static bool IsIdentifier(int c) { + return c < 128 && (character_classification[c] & 4); +} + +static int LowerCase(int c) +{ + if (c >= 'A' && c <= 'Z') + return 'a' + c - 'A'; + return c; +} + +static int CheckAPDLFoldPoint(char const *token, int &level) { + if (!strcmp(token, "*if") || + !strcmp(token, "*do") || + !strcmp(token, "*dowhile") ) { + level |= SC_FOLDLEVELHEADERFLAG; + return 1; + } + if (!strcmp(token, "*endif") || + !strcmp(token, "*enddo") ) { + return -1; + } + return 0; +} + +static void FoldAPDLDoc(unsigned int startPos, int length, int, + WordList *[], Accessor &styler) { + + int line = styler.GetLine(startPos); + int level = styler.LevelAt(line); + int go = 0, done = 0; + int endPos = startPos + length; + char word[256]; + int wordlen = 0; + int i; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + // Scan for tokens at the start of the line (they may include + // whitespace, for tokens like "End Function" + for (i = startPos; i < endPos; i++) { + int c = styler.SafeGetCharAt(i); + if (!done && !go) { + if (wordlen) { // are we scanning a token already? + word[wordlen] = static_cast(LowerCase(c)); + if (!IsIdentifier(c)) { // done with token + word[wordlen] = '\0'; + go = CheckAPDLFoldPoint(word, level); + if (!go) { + // Treat any whitespace as single blank, for + // things like "End Function". + if (IsSpace(c) && IsIdentifier(word[wordlen - 1])) { + word[wordlen] = ' '; + if (wordlen < 255) + wordlen++; + } + else // done with this line + done = 1; + } + } else if (wordlen < 255) { + wordlen++; + } + } else { // start scanning at first non-whitespace character + if (!IsSpace(c)) { + if (IsIdentifier(c)) { + word[0] = static_cast(LowerCase(c)); + wordlen = 1; + } else // done with this line + done = 1; + } + } + } + if (c == '\n') { // line end + if (!done && wordlen == 0 && foldCompact) // line was only space + level |= SC_FOLDLEVELWHITEFLAG; + if (level != styler.LevelAt(line)) + styler.SetLevel(line, level); + level += go; + line++; + // reset state + wordlen = 0; + level &= ~SC_FOLDLEVELHEADERFLAG; + level &= ~SC_FOLDLEVELWHITEFLAG; + go = 0; + done = 0; + } + } +} + +static const char * const apdlWordListDesc[] = { + "processors", + "commands", + "slashommands", + "starcommands", + "arguments", + "functions", + 0 +}; + +LexerModule lmAPDL(SCLEX_APDL, ColouriseAPDLDoc, "apdl", FoldAPDLDoc, apdlWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexASY.cxx b/sdk/wxscintilla/src/scintilla/src/LexASY.cxx new file mode 100644 index 0000000..5bf979f --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexASY.cxx @@ -0,0 +1,270 @@ +// Scintilla source code edit control +//Author: instanton (email: soft_share126com) +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "CharacterSet.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static void ColouriseAsyDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + + CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true); + CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true); + + int visibleChars = 0; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + if (sc.atLineStart) { + if (sc.state == SCE_ASY_STRING) { + sc.SetState(SCE_ASY_STRING); + } + visibleChars = 0; + } + + if (sc.ch == '\\') { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } +// continuationLine = true; + continue; + } + } + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_ASY_OPERATOR: + sc.SetState(SCE_ASY_DEFAULT); + break; + case SCE_ASY_NUMBER: + if (!setWord.Contains(sc.ch)) { + sc.SetState(SCE_ASY_DEFAULT); + } + break; + case SCE_ASY_IDENTIFIER: + if (!setWord.Contains(sc.ch) || (sc.ch == '.')) { + char s[1000]; + sc.GetCurrentLowered(s, sizeof(s)); + if (keywords.InList(s)) { + sc.ChangeState(SCE_ASY_WORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_ASY_WORD2); + } + sc.SetState(SCE_ASY_DEFAULT); + } + break; + case SCE_ASY_COMMENT: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_ASY_DEFAULT); + } + break; + case SCE_ASY_COMMENTLINE: + if (sc.atLineStart) { + sc.SetState(SCE_ASY_DEFAULT); + } + break; + case SCE_ASY_STRING: + if (sc.atLineEnd) { + sc.ChangeState(SCE_ASY_STRINGEOL); + } else if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\"') { + sc.ForwardSetState(SCE_ASY_DEFAULT); + } + break; + case SCE_ASY_CHARACTER: + if (sc.atLineEnd) { + sc.ChangeState(SCE_ASY_STRINGEOL); + } else if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\'') { + sc.ForwardSetState(SCE_ASY_DEFAULT); + } + break; + } + + // Determine if a new state should be entered. + if (sc.state == SCE_ASY_DEFAULT) { + if (setWordStart.Contains(sc.ch) || (sc.ch == '@')) { + sc.SetState(SCE_ASY_IDENTIFIER); + } else if (sc.Match('/', '*')) { + sc.SetState(SCE_ASY_COMMENT); + sc.Forward(); // + } else if (sc.Match('/', '/')) { + sc.SetState(SCE_ASY_COMMENTLINE); + } else if (sc.ch == '\"') { + sc.SetState(SCE_ASY_STRING); + } else if (sc.ch == '\'') { + sc.SetState(SCE_ASY_CHARACTER); + } else if (sc.ch == '#' && visibleChars == 0) { + do { + sc.Forward(); + } while ((sc.ch == ' ' || sc.ch == '\t') && sc.More()); + if (sc.atLineEnd) { + sc.SetState(SCE_ASY_DEFAULT); + } + } else if (isoperator(static_cast(sc.ch))) { + sc.SetState(SCE_ASY_OPERATOR); + } + } + + } + sc.Complete(); +} + +static bool IsAsyCommentStyle(int style) { + return style == SCE_ASY_COMMENT; +} + + +static inline bool isASYidentifier(int ch) { + return + ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) ; +} + +static int ParseASYWord(unsigned int pos, Accessor &styler, char *word) +{ + int length=0; + char ch=styler.SafeGetCharAt(pos); + *word=0; + + while(isASYidentifier(ch) && length<100){ + word[length]=ch; + length++; + ch=styler.SafeGetCharAt(pos+length); + } + word[length]=0; + return length; +} + +static bool IsASYDrawingLine(int line, Accessor &styler) { + int pos = styler.LineStart(line); + int eol_pos = styler.LineStart(line + 1) - 1; + + int startpos = pos; + char buffer[100]=""; + + while (startpos 0) + levelCurrent = styler.LevelAt(lineCurrent-1) >> 16; + int levelMinCurrent = levelCurrent; + int levelNext = levelCurrent; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (foldComment && IsAsyCommentStyle(style)) { + if (!IsAsyCommentStyle(stylePrev) && (stylePrev != SCE_ASY_COMMENTLINEDOC)) { + levelNext++; + } else if (!IsAsyCommentStyle(styleNext) && (styleNext != SCE_ASY_COMMENTLINEDOC) && !atEOL) { + levelNext--; + } + } + if (style == SCE_ASY_OPERATOR) { + if (ch == '{') { + if (levelMinCurrent > levelNext) { + levelMinCurrent = levelNext; + } + levelNext++; + } else if (ch == '}') { + levelNext--; + } + } + + if (atEOL && IsASYDrawingLine(lineCurrent, styler)){ + if (lineCurrent==0 && IsASYDrawingLine(lineCurrent + 1, styler)) + levelNext++; + else if (lineCurrent!=0 && !IsASYDrawingLine(lineCurrent - 1, styler) + && IsASYDrawingLine(lineCurrent + 1, styler) + ) + levelNext++; + else if (lineCurrent!=0 && IsASYDrawingLine(lineCurrent - 1, styler) && + !IsASYDrawingLine(lineCurrent+1, styler)) + levelNext--; + } + + if (atEOL) { + int levelUse = levelCurrent; + if (foldAtElse) { + levelUse = levelMinCurrent; + } + int lev = levelUse | levelNext << 16; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if (levelUse < levelNext) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelCurrent = levelNext; + levelMinCurrent = levelCurrent; + visibleChars = 0; + } + if (!IsASpace(ch)) + visibleChars++; + } +} + +static const char * const asyWordLists[] = { + "Primary keywords and identifiers", + "Secondary keywords and identifiers", + 0, + }; + +LexerModule lmASY(SCLEX_ASYMPTOTE, ColouriseAsyDoc, "asy", FoldAsyDoc, asyWordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexAU3.cxx b/sdk/wxscintilla/src/scintilla/src/LexAU3.cxx new file mode 100644 index 0000000..cfff927 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAU3.cxx @@ -0,0 +1,907 @@ +// Scintilla source code edit control +// @file LexAU3.cxx +// Lexer for AutoIt3 http://www.hiddensoft.com/autoit3 +// by Jos van der Zande, jvdzande@yahoo.com +// +// Changes: +// March 28, 2004 - Added the standard Folding code +// April 21, 2004 - Added Preprosessor Table + Syntax Highlighting +// Fixed Number highlighting +// Changed default isoperator to IsAOperator to have a better match to AutoIt3 +// Fixed "#comments_start" -> "#comments-start" +// Fixed "#comments_end" -> "#comments-end" +// Fixed Sendkeys in Strings when not terminated with } +// Added support for Sendkey strings that have second parameter e.g. {UP 5} or {a down} +// April 26, 2004 - Fixed # pre-processor statement inside of comment block would invalidly change the color. +// Added logic for #include to treat the <> as string +// Added underscore to IsAOperator. +// May 17, 2004 - Changed the folding logic from indent to keyword folding. +// Added Folding logic for blocks of single-commentlines or commentblock. +// triggered by: fold.comment=1 +// Added Folding logic for preprocessor blocks triggered by fold.preprocessor=1 +// Added Special for #region - #endregion syntax highlight and folding. +// May 30, 2004 - Fixed issue with continuation lines on If statements. +// June 5, 2004 - Added comma to Operators for better readability. +// Added fold.compact support set with fold.compact=1 +// Changed folding inside of #cs-#ce. Default is no keyword folding inside comment blocks when fold.comment=1 +// it will now only happen when fold.comment=2. +// Sep 5, 2004 - Added logic to handle colourizing words on the last line. +// Typed Characters now show as "default" till they match any table. +// Oct 10, 2004 - Added logic to show Comments in "Special" directives. +// Nov 1, 2004 - Added better testing for Numbers supporting x and e notation. +// Nov 28, 2004 - Added logic to handle continuation lines for syntax highlighting. +// Jan 10, 2005 - Added Abbreviations Keyword used for expansion +// Mar 24, 2005 - Updated Abbreviations Keywords to fix when followed by Operator. +// Apr 18, 2005 - Updated #CE/#Comment-End logic to take a linecomment ";" into account +// - Added folding support for With...EndWith +// - Added support for a DOT in variable names +// - Fixed Underscore in CommentBlock +// May 23, 2005 - Fixed the SentKey lexing in case of a missing } +// Aug 11, 2005 - Fixed possible bug with s_save length > 100. +// Aug 23, 2005 - Added Switch/endswitch support to the folding logic. +// Sep 27, 2005 - Fixed the SentKey lexing logic in case of multiple sentkeys. +// Mar 12, 2006 - Fixed issue with <> coloring as String in stead of Operator in rare occasions. +// Apr 8, 2006 - Added support for AutoIt3 Standard UDF library (SCE_AU3_UDF) +// Mar 9, 2007 - Fixed bug with + following a String getting the wrong Color. +// Jun 20, 2007 - Fixed Commentblock issue when LF's are used as EOL. +// Jul 26, 2007 - Fixed #endregion undetected bug. +// +// Copyright for Scintilla: 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. +// Scintilla source code edit control + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsTypeCharacter(const int ch) +{ + return ch == '$'; +} +static inline bool IsAWordChar(const int ch) +{ + return (ch < 0x80) && (isalnum(ch) || ch == '_'); +} + +static inline bool IsAWordStart(const int ch) +{ + return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '@' || ch == '#' || ch == '$' || ch == '.'); +} + +static inline bool IsAOperator(char ch) { + if (isascii(ch) && isalnum(ch)) + return false; + if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || + ch == '&' || ch == '^' || ch == '=' || ch == '<' || ch == '>' || + ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == ',' ) + return true; + return false; +} + +/////////////////////////////////////////////////////////////////////////////// +// GetSendKey() filters the portion before and after a/multiple space(s) +// and return the first portion to be looked-up in the table +// also check if the second portion is valid... (up,down.on.off,toggle or a number) +/////////////////////////////////////////////////////////////////////////////// + +static int GetSendKey(const char *szLine, char *szKey) +{ + int nFlag = 0; + int nStartFound = 0; + int nKeyPos = 0; + int nSpecPos= 0; + int nSpecNum= 1; + int nPos = 0; + char cTemp; + char szSpecial[100]; + + // split the portion of the sendkey in the part before and after the spaces + while ( ( (cTemp = szLine[nPos]) != '\0')) + { + // skip leading Ctrl/Shift/Alt state + if (cTemp == '{') { + nStartFound = 1; + } + // + if (nStartFound == 1) { + if ((cTemp == ' ') && (nFlag == 0) ) // get the stuff till first space + { + nFlag = 1; + // Add } to the end of the first bit for table lookup later. + szKey[nKeyPos++] = '}'; + } + else if (cTemp == ' ') + { + // skip other spaces + } + else if (nFlag == 0) + { + // save first portion into var till space or } is hit + szKey[nKeyPos++] = cTemp; + } + else if ((nFlag == 1) && (cTemp != '}')) + { + // Save second portion into var... + szSpecial[nSpecPos++] = cTemp; + // check if Second portion is all numbers for repeat fuction + if (isdigit(cTemp) == false) {nSpecNum = 0;} + } + } + nPos++; // skip to next char + + } // End While + + + // Check if the second portion is either a number or one of these keywords + szKey[nKeyPos] = '\0'; + szSpecial[nSpecPos] = '\0'; + if (strcmp(szSpecial,"down")== 0 || strcmp(szSpecial,"up")== 0 || + strcmp(szSpecial,"on")== 0 || strcmp(szSpecial,"off")== 0 || + strcmp(szSpecial,"toggle")== 0 || nSpecNum == 1 ) + { + nFlag = 0; + } + else + { + nFlag = 1; + } + return nFlag; // 1 is bad, 0 is good + +} // GetSendKey() + +// +// Routine to check the last "none comment" character on a line to see if its a continuation +// +static bool IsContinuationLine(unsigned int szLine, Accessor &styler) +{ + int nsPos = styler.LineStart(szLine); + int nePos = styler.LineStart(szLine+1) - 2; + //int stylech = styler.StyleAt(nsPos); + while (nsPos < nePos) + { + //stylech = styler.StyleAt(nePos); + int stylech = styler.StyleAt(nsPos); + if (!(stylech == SCE_AU3_COMMENT)) { + char ch = styler.SafeGetCharAt(nePos); + if (!isspacechar(ch)) { + if (ch == '_') + return true; + else + return false; + } + } + nePos--; // skip to next char + } // End While + return false; +} // IsContinuationLine() + +// +// syntax highlighting logic +static void ColouriseAU3Doc(unsigned int startPos, + int length, int initStyle, + WordList *keywordlists[], + Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + WordList &keywords4 = *keywordlists[3]; + WordList &keywords5 = *keywordlists[4]; + WordList &keywords6 = *keywordlists[5]; + WordList &keywords7 = *keywordlists[6]; + WordList &keywords8 = *keywordlists[7]; + // find the first previous line without continuation character at the end + int lineCurrent = styler.GetLine(startPos); + int s_startPos = startPos; + // When not inside a Block comment: find First line without _ + if (!(initStyle==SCE_AU3_COMMENTBLOCK)) { + while ((lineCurrent > 0 && IsContinuationLine(lineCurrent,styler)) || + (lineCurrent > 1 && IsContinuationLine(lineCurrent-1,styler))) { + lineCurrent--; + startPos = styler.LineStart(lineCurrent); // get start position + initStyle = 0; // reset the start style to 0 + } + } + // Set the new length to include it from the start and set the start position + length = length + s_startPos - startPos; // correct the total length to process + styler.StartAt(startPos); + + StyleContext sc(startPos, length, initStyle, styler); + char si; // string indicator "=1 '=2 + char ni; // Numeric indicator error=9 normal=0 normal+dec=1 hex=2 Enot=3 + char ci; // comment indicator 0=not linecomment(;) + char s_save[100]; + si=0; + ni=0; + ci=0; + //$$$ + for (; sc.More(); sc.Forward()) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + // ********************************************** + // save the total current word for eof processing + if (IsAWordChar(sc.ch) || sc.ch == '}') + { + strcpy(s_save,s); + int tp = strlen(s_save); + if (tp < 99) { + s_save[tp] = static_cast(tolower(sc.ch)); + s_save[tp+1] = '\0'; + } + } + // ********************************************** + // + switch (sc.state) + { + case SCE_AU3_COMMENTBLOCK: + { + //Reset at line end + if (sc.atLineEnd) { + ci=0; + if (strcmp(s, "#ce")== 0 || strcmp(s, "#comments-end")== 0) { + if (sc.atLineEnd) + sc.SetState(SCE_AU3_DEFAULT); + else + sc.SetState(SCE_AU3_COMMENTBLOCK); + } + break; + } + //skip rest of line when a ; is encountered + if (sc.chPrev == ';') { + ci=2; + sc.SetState(SCE_AU3_COMMENTBLOCK); + } + // skip rest of the line + if (ci==2) + break; + // check when first character is detected on the line + if (ci==0) { + if (IsAWordStart(static_cast(sc.ch)) || IsAOperator(static_cast(sc.ch))) { + ci=1; + sc.SetState(SCE_AU3_COMMENTBLOCK); + } + break; + } + if (!(IsAWordChar(sc.ch) || (sc.ch == '-' && strcmp(s, "#comments") == 0))) { + if ((strcmp(s, "#ce")== 0 || strcmp(s, "#comments-end")== 0)) + sc.SetState(SCE_AU3_COMMENT); // set to comment line for the rest of the line + else + ci=2; // line doesn't begin with #CE so skip the rest of the line + } + break; + } + case SCE_AU3_COMMENT: + { + if (sc.atLineEnd) {sc.SetState(SCE_AU3_DEFAULT);} + break; + } + case SCE_AU3_OPERATOR: + { + // check if its a COMobject + if (sc.chPrev == '.' && IsAWordChar(sc.ch)) { + sc.SetState(SCE_AU3_COMOBJ); + } + else { + sc.SetState(SCE_AU3_DEFAULT); + } + break; + } + case SCE_AU3_SPECIAL: + { + if (sc.ch == ';') {sc.SetState(SCE_AU3_COMMENT);} + if (sc.atLineEnd) {sc.SetState(SCE_AU3_DEFAULT);} + break; + } + case SCE_AU3_KEYWORD: + { + if (!(IsAWordChar(sc.ch) || (sc.ch == '-' && (strcmp(s, "#comments") == 0 || strcmp(s, "#include") == 0)))) + { + if (!IsTypeCharacter(sc.ch)) + { + if (strcmp(s, "#cs")== 0 || strcmp(s, "#comments-start")== 0 ) + { + sc.ChangeState(SCE_AU3_COMMENTBLOCK); + sc.SetState(SCE_AU3_COMMENTBLOCK); + break; + } + else if (keywords.InList(s)) { + sc.ChangeState(SCE_AU3_KEYWORD); + sc.SetState(SCE_AU3_DEFAULT); + } + else if (keywords2.InList(s)) { + sc.ChangeState(SCE_AU3_FUNCTION); + sc.SetState(SCE_AU3_DEFAULT); + } + else if (keywords3.InList(s)) { + sc.ChangeState(SCE_AU3_MACRO); + sc.SetState(SCE_AU3_DEFAULT); + } + else if (keywords5.InList(s)) { + sc.ChangeState(SCE_AU3_PREPROCESSOR); + sc.SetState(SCE_AU3_DEFAULT); + if (strcmp(s, "#include")== 0) + { + si = 3; // use to determine string start for #inlude <> + } + } + else if (keywords6.InList(s)) { + sc.ChangeState(SCE_AU3_SPECIAL); + sc.SetState(SCE_AU3_SPECIAL); + } + else if ((keywords7.InList(s)) && (!IsAOperator(static_cast(sc.ch)))) { + sc.ChangeState(SCE_AU3_EXPAND); + sc.SetState(SCE_AU3_DEFAULT); + } + else if (keywords8.InList(s)) { + sc.ChangeState(SCE_AU3_UDF); + sc.SetState(SCE_AU3_DEFAULT); + } + else if (strcmp(s, "_") == 0) { + sc.ChangeState(SCE_AU3_OPERATOR); + sc.SetState(SCE_AU3_DEFAULT); + } + else if (!IsAWordChar(sc.ch)) { + sc.ChangeState(SCE_AU3_DEFAULT); + sc.SetState(SCE_AU3_DEFAULT); + } + } + } + if (sc.atLineEnd) { + sc.SetState(SCE_AU3_DEFAULT);} + break; + } + case SCE_AU3_NUMBER: + { + // Numeric indicator error=9 normal=0 normal+dec=1 hex=2 E-not=3 + // + // test for Hex notation + if (strcmp(s, "0") == 0 && (sc.ch == 'x' || sc.ch == 'X') && ni == 0) + { + ni = 2; + break; + } + // test for E notation + if (IsADigit(sc.chPrev) && (sc.ch == 'e' || sc.ch == 'E') && ni <= 1) + { + ni = 3; + break; + } + // Allow Hex characters inside hex numeric strings + if ((ni == 2) && + (sc.ch == 'a' || sc.ch == 'b' || sc.ch == 'c' || sc.ch == 'd' || sc.ch == 'e' || sc.ch == 'f' || + sc.ch == 'A' || sc.ch == 'B' || sc.ch == 'C' || sc.ch == 'D' || sc.ch == 'E' || sc.ch == 'F' )) + { + break; + } + // test for 1 dec point only + if (sc.ch == '.') + { + if (ni==0) + { + ni=1; + } + else + { + ni=9; + } + break; + } + // end of numeric string ? + if (!(IsADigit(sc.ch))) + { + if (ni==9) + { + sc.ChangeState(SCE_AU3_DEFAULT); + } + sc.SetState(SCE_AU3_DEFAULT); + } + break; + } + case SCE_AU3_VARIABLE: + { + // Check if its a COMObject + if (sc.ch == '.' && !IsADigit(sc.chNext)) { + sc.SetState(SCE_AU3_OPERATOR); + } + else if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_AU3_DEFAULT); + } + break; + } + case SCE_AU3_COMOBJ: + { + if (!(IsAWordChar(sc.ch))) { + sc.SetState(SCE_AU3_DEFAULT); + } + break; + } + case SCE_AU3_STRING: + { + // check for " to end a double qouted string or + // check for ' to end a single qouted string + if ((si == 1 && sc.ch == '\"') || (si == 2 && sc.ch == '\'') || (si == 3 && sc.ch == '>')) + { + sc.ForwardSetState(SCE_AU3_DEFAULT); + si=0; + break; + } + if (sc.atLineEnd) + { + si=0; + // at line end and not found a continuation char then reset to default + int lineCurrent = styler.GetLine(sc.currentPos); + if (!IsContinuationLine(lineCurrent,styler)) + { + sc.SetState(SCE_AU3_DEFAULT); + break; + } + } + // find Sendkeys in a STRING + if (sc.ch == '{' || sc.ch == '+' || sc.ch == '!' || sc.ch == '^' || sc.ch == '#' ) { + sc.SetState(SCE_AU3_SENT);} + break; + } + + case SCE_AU3_SENT: + { + // Send key string ended + if (sc.chPrev == '}' && sc.ch != '}') + { + // set color to SENDKEY when valid sendkey .. else set back to regular string + char sk[100]; + // split {111 222} and return {111} and check if 222 is valid. + // if return code = 1 then invalid 222 so must be string + if (GetSendKey(s,sk)) + { + sc.ChangeState(SCE_AU3_STRING); + } + // if single char between {?} then its ok as sendkey for a single character + else if (strlen(sk) == 3) + { + sc.ChangeState(SCE_AU3_SENT); + } + // if sendkey {111} is in table then ok as sendkey + else if (keywords4.InList(sk)) + { + sc.ChangeState(SCE_AU3_SENT); + } + else + { + sc.ChangeState(SCE_AU3_STRING); + } + sc.SetState(SCE_AU3_STRING); + } + else + { + // check if the start is a valid SendKey start + int nPos = 0; + int nState = 1; + char cTemp; + while (!(nState == 2) && ((cTemp = s[nPos]) != '\0')) + { + if (cTemp == '{' && nState == 1) + { + nState = 2; + } + if (nState == 1 && !(cTemp == '+' || cTemp == '!' || cTemp == '^' || cTemp == '#' )) + { + nState = 0; + } + nPos++; + } + //Verify characters infront of { ... if not assume regular string + if (nState == 1 && (!(sc.ch == '{' || sc.ch == '+' || sc.ch == '!' || sc.ch == '^' || sc.ch == '#' ))) { + sc.ChangeState(SCE_AU3_STRING); + sc.SetState(SCE_AU3_STRING); + } + // If invalid character found then assume its a regular string + if (nState == 0) { + sc.ChangeState(SCE_AU3_STRING); + sc.SetState(SCE_AU3_STRING); + } + } + // check if next portion is again a sendkey + if (sc.atLineEnd) + { + sc.ChangeState(SCE_AU3_STRING); + sc.SetState(SCE_AU3_DEFAULT); + si = 0; // reset string indicator + } + //* check in next characters following a sentkey are again a sent key + // Need this test incase of 2 sentkeys like {F1}{ENTER} but not detect {{} + if (sc.state == SCE_AU3_STRING && (sc.ch == '{' || sc.ch == '+' || sc.ch == '!' || sc.ch == '^' || sc.ch == '#' )) { + sc.SetState(SCE_AU3_SENT);} + // check to see if the string ended... + // Sendkey string isn't complete but the string ended.... + if ((si == 1 && sc.ch == '\"') || (si == 2 && sc.ch == '\'')) + { + sc.ChangeState(SCE_AU3_STRING); + sc.ForwardSetState(SCE_AU3_DEFAULT); + } + break; + } + } //switch (sc.state) + + // Determine if a new state should be entered: + + if (sc.state == SCE_AU3_DEFAULT) + { + if (sc.ch == ';') {sc.SetState(SCE_AU3_COMMENT);} + else if (sc.ch == '#') {sc.SetState(SCE_AU3_KEYWORD);} + else if (sc.ch == '$') {sc.SetState(SCE_AU3_VARIABLE);} + else if (sc.ch == '.' && !IsADigit(sc.chNext)) {sc.SetState(SCE_AU3_OPERATOR);} + else if (sc.ch == '@') {sc.SetState(SCE_AU3_KEYWORD);} + //else if (sc.ch == '_') {sc.SetState(SCE_AU3_KEYWORD);} + else if (sc.ch == '<' && si==3) {sc.SetState(SCE_AU3_STRING);} // string after #include + else if (sc.ch == '\"') { + sc.SetState(SCE_AU3_STRING); + si = 1; } + else if (sc.ch == '\'') { + sc.SetState(SCE_AU3_STRING); + si = 2; } + else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) + { + sc.SetState(SCE_AU3_NUMBER); + ni = 0; + } + else if (IsAWordStart(sc.ch)) {sc.SetState(SCE_AU3_KEYWORD);} + else if (IsAOperator(static_cast(sc.ch))) {sc.SetState(SCE_AU3_OPERATOR);} + else if (sc.atLineEnd) {sc.SetState(SCE_AU3_DEFAULT);} + } + } //for (; sc.More(); sc.Forward()) + + //************************************* + // Colourize the last word correctly + //************************************* + if (sc.state == SCE_AU3_KEYWORD) + { + if (strcmp(s_save, "#cs")== 0 || strcmp(s_save, "#comments-start")== 0 ) + { + sc.ChangeState(SCE_AU3_COMMENTBLOCK); + sc.SetState(SCE_AU3_COMMENTBLOCK); + } + else if (keywords.InList(s_save)) { + sc.ChangeState(SCE_AU3_KEYWORD); + sc.SetState(SCE_AU3_KEYWORD); + } + else if (keywords2.InList(s_save)) { + sc.ChangeState(SCE_AU3_FUNCTION); + sc.SetState(SCE_AU3_FUNCTION); + } + else if (keywords3.InList(s_save)) { + sc.ChangeState(SCE_AU3_MACRO); + sc.SetState(SCE_AU3_MACRO); + } + else if (keywords5.InList(s_save)) { + sc.ChangeState(SCE_AU3_PREPROCESSOR); + sc.SetState(SCE_AU3_PREPROCESSOR); + } + else if (keywords6.InList(s_save)) { + sc.ChangeState(SCE_AU3_SPECIAL); + sc.SetState(SCE_AU3_SPECIAL); + } + else if (keywords7.InList(s_save) && sc.atLineEnd) { + sc.ChangeState(SCE_AU3_EXPAND); + sc.SetState(SCE_AU3_EXPAND); + } + else if (keywords8.InList(s_save)) { + sc.ChangeState(SCE_AU3_UDF); + sc.SetState(SCE_AU3_UDF); + } + else { + sc.ChangeState(SCE_AU3_DEFAULT); + sc.SetState(SCE_AU3_DEFAULT); + } + } + if (sc.state == SCE_AU3_SENT) + { + // Send key string ended + if (sc.chPrev == '}' && sc.ch != '}') + { + // set color to SENDKEY when valid sendkey .. else set back to regular string + char sk[100]; + // split {111 222} and return {111} and check if 222 is valid. + // if return code = 1 then invalid 222 so must be string + if (GetSendKey(s_save,sk)) + { + sc.ChangeState(SCE_AU3_STRING); + } + // if single char between {?} then its ok as sendkey for a single character + else if (strlen(sk) == 3) + { + sc.ChangeState(SCE_AU3_SENT); + } + // if sendkey {111} is in table then ok as sendkey + else if (keywords4.InList(sk)) + { + sc.ChangeState(SCE_AU3_SENT); + } + else + { + sc.ChangeState(SCE_AU3_STRING); + } + sc.SetState(SCE_AU3_STRING); + } + // check if next portion is again a sendkey + if (sc.atLineEnd) + { + sc.ChangeState(SCE_AU3_STRING); + sc.SetState(SCE_AU3_DEFAULT); + } + } + //************************************* + sc.Complete(); +} + +// +static bool IsStreamCommentStyle(int style) { + return style == SCE_AU3_COMMENT || style == SCE_AU3_COMMENTBLOCK; +} + +// +// Routine to find first none space on the current line and return its Style +// needed for comment lines not starting on pos 1 +static int GetStyleFirstWord(unsigned int szLine, Accessor &styler) +{ + int nsPos = styler.LineStart(szLine); + int nePos = styler.LineStart(szLine+1) - 1; + while (isspacechar(styler.SafeGetCharAt(nsPos)) && nsPos < nePos) + { + nsPos++; // skip to next char + + } // End While + return styler.StyleAt(nsPos); + +} // GetStyleFirstWord() + + +// +static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) +{ + int endPos = startPos + length; + // get settings from the config files for folding comments and preprocessor lines + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + bool foldInComment = styler.GetPropertyInt("fold.comment") == 2; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + bool foldpreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0; + // Backtrack to previous line in case need to fix its fold status + int lineCurrent = styler.GetLine(startPos); + if (startPos > 0) { + if (lineCurrent > 0) { + lineCurrent--; + startPos = styler.LineStart(lineCurrent); + } + } + // vars for style of previous/current/next lines + int style = GetStyleFirstWord(lineCurrent,styler); + int stylePrev = 0; + // find the first previous line without continuation character at the end + while ((lineCurrent > 0 && IsContinuationLine(lineCurrent,styler)) || + (lineCurrent > 1 && IsContinuationLine(lineCurrent-1,styler))) { + lineCurrent--; + startPos = styler.LineStart(lineCurrent); + } + if (lineCurrent > 0) { + stylePrev = GetStyleFirstWord(lineCurrent-1,styler); + } + // vars for getting first word to check for keywords + bool FirstWordStart = false; + bool FirstWordEnd = false; + char szKeyword[11]=""; + int szKeywordlen = 0; + char szThen[5]=""; + int szThenlen = 0; + bool ThenFoundLast = false; + // var for indentlevel + int levelCurrent = SC_FOLDLEVELBASE; + if (lineCurrent > 0) + levelCurrent = styler.LevelAt(lineCurrent-1) >> 16; + int levelNext = levelCurrent; + // + int visibleChars = 0; + char chNext = styler.SafeGetCharAt(startPos); + char chPrev = ' '; + // + for (int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + if (IsAWordChar(ch)) { + visibleChars++; + } + // get the syle for the current character neede to check in comment + int stylech = styler.StyleAt(i); + // get first word for the line for indent check max 9 characters + if (FirstWordStart && (!(FirstWordEnd))) { + if (!IsAWordChar(ch)) { + FirstWordEnd = true; + szKeyword[szKeywordlen] = '\0'; + } + else { + if (szKeywordlen < 10) { + szKeyword[szKeywordlen++] = static_cast(tolower(ch)); + } + } + } + // start the capture of the first word + if (!(FirstWordStart)) { + if (IsAWordChar(ch) || IsAWordStart(ch) || ch == ';') { + FirstWordStart = true; + szKeyword[szKeywordlen++] = static_cast(tolower(ch)); + } + } + // only process this logic when not in comment section + if (!(stylech == SCE_AU3_COMMENT)) { + if (ThenFoundLast) { + if (IsAWordChar(ch)) { + ThenFoundLast = false; + } + } + // find out if the word "then" is the last on a "if" line + if (FirstWordEnd && strcmp(szKeyword,"if") == 0) { + if (szThenlen == 4) { + szThen[0] = szThen[1]; + szThen[1] = szThen[2]; + szThen[2] = szThen[3]; + szThen[3] = static_cast(tolower(ch)); + if (strcmp(szThen,"then") == 0 ) { + ThenFoundLast = true; + } + } + else { + szThen[szThenlen++] = static_cast(tolower(ch)); + if (szThenlen == 5) { + szThen[4] = '\0'; + } + } + } + } + // End of Line found so process the information + if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == endPos)) { + // ************************** + // Folding logic for Keywords + // ************************** + // if a keyword is found on the current line and the line doesn't end with _ (continuation) + // and we are not inside a commentblock. + if (szKeywordlen > 0 && (!(chPrev == '_')) && + ((!(IsStreamCommentStyle(style)) || foldInComment)) ) { + szKeyword[szKeywordlen] = '\0'; + // only fold "if" last keyword is "then" (else its a one line if) + if (strcmp(szKeyword,"if") == 0 && ThenFoundLast) { + levelNext++; + } + // create new fold for these words + if (strcmp(szKeyword,"do") == 0 || strcmp(szKeyword,"for") == 0 || + strcmp(szKeyword,"func") == 0 || strcmp(szKeyword,"while") == 0|| + strcmp(szKeyword,"with") == 0 || strcmp(szKeyword,"#region") == 0 ) { + levelNext++; + } + // create double Fold for select&switch because Case will subtract one of the current level + if (strcmp(szKeyword,"select") == 0 || strcmp(szKeyword,"switch") == 0) { + levelNext++; + levelNext++; + } + // end the fold for these words before the current line + if (strcmp(szKeyword,"endfunc") == 0 || strcmp(szKeyword,"endif") == 0 || + strcmp(szKeyword,"next") == 0 || strcmp(szKeyword,"until") == 0 || + strcmp(szKeyword,"endwith") == 0 ||strcmp(szKeyword,"wend") == 0){ + levelNext--; + levelCurrent--; + } + // end the fold for these words before the current line and Start new fold + if (strcmp(szKeyword,"case") == 0 || strcmp(szKeyword,"else") == 0 || + strcmp(szKeyword,"elseif") == 0 ) { + levelCurrent--; + } + // end the double fold for this word before the current line + if (strcmp(szKeyword,"endselect") == 0 || strcmp(szKeyword,"endswitch") == 0 ) { + levelNext--; + levelNext--; + levelCurrent--; + levelCurrent--; + } + // end the fold for these words on the current line + if (strcmp(szKeyword,"#endregion") == 0 ) { + levelNext--; + } + } + // Preprocessor and Comment folding + int styleNext = GetStyleFirstWord(lineCurrent + 1,styler); + // ************************************* + // Folding logic for preprocessor blocks + // ************************************* + // process preprosessor line + if (foldpreprocessor && style == SCE_AU3_PREPROCESSOR) { + if (!(stylePrev == SCE_AU3_PREPROCESSOR) && (styleNext == SCE_AU3_PREPROCESSOR)) { + levelNext++; + } + // fold till the last line for normal comment lines + else if (stylePrev == SCE_AU3_PREPROCESSOR && !(styleNext == SCE_AU3_PREPROCESSOR)) { + levelNext--; + } + } + // ********************************* + // Folding logic for Comment blocks + // ********************************* + if (foldComment && IsStreamCommentStyle(style)) { + // Start of a comment block + if (!(stylePrev==style) && IsStreamCommentStyle(styleNext) && styleNext==style) { + levelNext++; + } + // fold till the last line for normal comment lines + else if (IsStreamCommentStyle(stylePrev) + && !(styleNext == SCE_AU3_COMMENT) + && stylePrev == SCE_AU3_COMMENT + && style == SCE_AU3_COMMENT) { + levelNext--; + } + // fold till the one but last line for Blockcomment lines + else if (IsStreamCommentStyle(stylePrev) + && !(styleNext == SCE_AU3_COMMENTBLOCK) + && style == SCE_AU3_COMMENTBLOCK) { + levelNext--; + levelCurrent--; + } + } + int levelUse = levelCurrent; + int lev = levelUse | levelNext << 16; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if (levelUse < levelNext) { + lev |= SC_FOLDLEVELHEADERFLAG; + } + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + // reset values for the next line + lineCurrent++; + stylePrev = style; + style = styleNext; + levelCurrent = levelNext; + visibleChars = 0; + // if the last character is an Underscore then don't reset since the line continues on the next line. + if (!(chPrev == '_')) { + szKeywordlen = 0; + szThenlen = 0; + FirstWordStart = false; + FirstWordEnd = false; + ThenFoundLast = false; + } + } + // save the last processed character + if (!isspacechar(ch)) { + chPrev = ch; + visibleChars++; + } + } +} + + +// + +static const char * const AU3WordLists[] = { + "#autoit keywords", + "#autoit functions", + "#autoit macros", + "#autoit Sent keys", + "#autoit Pre-processors", + "#autoit Special", + "#autoit Expand", + "#autoit UDF", + 0 +}; +LexerModule lmAU3(SCLEX_AU3, ColouriseAU3Doc, "au3", FoldAU3Doc , AU3WordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexAVE.cxx b/sdk/wxscintilla/src/scintilla/src/LexAVE.cxx new file mode 100644 index 0000000..09b3933 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAVE.cxx @@ -0,0 +1,228 @@ +// SciTE - Scintilla based Text Editor +/** @file LexAVE.cxx + ** Lexer for Avenue. + ** + ** Written by Alexey Yutkin . + **/ +// Copyright 1998-2002 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_'); +} +static inline bool IsEnumChar(const int ch) { + return (ch < 0x80) && (isalnum(ch)|| ch == '_'); +} +static inline bool IsANumberChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' ); +} + +inline bool IsAWordStart(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_'); +} + +inline bool isAveOperator(char ch) { + if (isascii(ch) && isalnum(ch)) + return false; + // '.' left out as it is used to make up numbers + if (ch == '*' || ch == '/' || ch == '-' || ch == '+' || + ch == '(' || ch == ')' || ch == '=' || + ch == '{' || ch == '}' || + ch == '[' || ch == ']' || ch == ';' || + ch == '<' || ch == '>' || ch == ',' || + ch == '.' ) + return true; + return false; +} + +static void ColouriseAveDoc( + unsigned int startPos, + int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + WordList &keywords4 = *keywordlists[3]; + WordList &keywords5 = *keywordlists[4]; + WordList &keywords6 = *keywordlists[5]; + + // Do not leak onto next line + if (initStyle == SCE_AVE_STRINGEOL) { + initStyle = SCE_AVE_DEFAULT; + } + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + if (sc.atLineEnd) { + // Update the line state, so it can be seen by next line + int currentLine = styler.GetLine(sc.currentPos); + styler.SetLineState(currentLine, 0); + } + if (sc.atLineStart && (sc.state == SCE_AVE_STRING)) { + // Prevent SCE_AVE_STRINGEOL from leaking back to previous line + sc.SetState(SCE_AVE_STRING); + } + + + // Determine if the current state should terminate. + if (sc.state == SCE_AVE_OPERATOR) { + sc.SetState(SCE_AVE_DEFAULT); + } else if (sc.state == SCE_AVE_NUMBER) { + if (!IsANumberChar(sc.ch)) { + sc.SetState(SCE_AVE_DEFAULT); + } + } else if (sc.state == SCE_AVE_ENUM) { + if (!IsEnumChar(sc.ch)) { + sc.SetState(SCE_AVE_DEFAULT); + } + } else if (sc.state == SCE_AVE_IDENTIFIER) { + if (!IsAWordChar(sc.ch) || (sc.ch == '.')) { + char s[100]; + //sc.GetCurrent(s, sizeof(s)); + sc.GetCurrentLowered(s, sizeof(s)); + if (keywords.InList(s)) { + sc.ChangeState(SCE_AVE_WORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_AVE_WORD2); + } else if (keywords3.InList(s)) { + sc.ChangeState(SCE_AVE_WORD3); + } else if (keywords4.InList(s)) { + sc.ChangeState(SCE_AVE_WORD4); + } else if (keywords5.InList(s)) { + sc.ChangeState(SCE_AVE_WORD5); + } else if (keywords6.InList(s)) { + sc.ChangeState(SCE_AVE_WORD6); + } + sc.SetState(SCE_AVE_DEFAULT); + } + } else if (sc.state == SCE_AVE_COMMENT) { + if (sc.atLineEnd) { + sc.SetState(SCE_AVE_DEFAULT); + } + } else if (sc.state == SCE_AVE_STRING) { + if (sc.ch == '\"') { + sc.ForwardSetState(SCE_AVE_DEFAULT); + } else if (sc.atLineEnd) { + sc.ChangeState(SCE_AVE_STRINGEOL); + sc.ForwardSetState(SCE_AVE_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_AVE_DEFAULT) { + if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_AVE_NUMBER); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_AVE_IDENTIFIER); + } else if (sc.Match('\"')) { + sc.SetState(SCE_AVE_STRING); + } else if (sc.Match('\'')) { + sc.SetState(SCE_AVE_COMMENT); + sc.Forward(); + } else if (isAveOperator(static_cast(sc.ch))) { + sc.SetState(SCE_AVE_OPERATOR); + } else if (sc.Match('#')) { + sc.SetState(SCE_AVE_ENUM); + sc.Forward(); + } + } + } + sc.Complete(); +} + +static void FoldAveDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[], + Accessor &styler) { + unsigned int lengthDoc = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = static_cast(tolower(styler[startPos])); + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + int styleNext = styler.StyleAt(startPos); + char s[10]; + + for (unsigned int i = startPos; i < lengthDoc; i++) { + char ch = static_cast(tolower(chNext)); + chNext = static_cast(tolower(styler.SafeGetCharAt(i + 1))); + int style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (style == SCE_AVE_WORD) { + if (ch == 't' || ch == 'f' || ch == 'w' || ch == 'e') { + for (unsigned int j = 0; j < 6; j++) { + if (!iswordchar(styler[i + j])) { + break; + } + s[j] = static_cast(tolower(styler[i + j])); + s[j + 1] = '\0'; + } + + if ((strcmp(s, "then") == 0) || (strcmp(s, "for") == 0) || (strcmp(s, "while") == 0)) { + levelCurrent++; + } + if ((strcmp(s, "end") == 0) || (strcmp(s, "elseif") == 0)) { + // Normally "elseif" and "then" will be on the same line and will cancel + // each other out. // As implemented, this does not support fold.at.else. + levelCurrent--; + } + } + } else if (style == SCE_AVE_OPERATOR) { + if (ch == '{' || ch == '(') { + levelCurrent++; + } else if (ch == '}' || ch == ')') { + levelCurrent--; + } + } + + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) { + lev |= SC_FOLDLEVELWHITEFLAG; + } + if ((levelCurrent > levelPrev) && (visibleChars > 0)) { + lev |= SC_FOLDLEVELHEADERFLAG; + } + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) { + visibleChars++; + } + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +LexerModule lmAVE(SCLEX_AVE, ColouriseAveDoc, "ave", FoldAveDoc); + diff --git a/sdk/wxscintilla/src/scintilla/src/LexAbaqus.cxx b/sdk/wxscintilla/src/scintilla/src/LexAbaqus.cxx new file mode 100644 index 0000000..10e8b76 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAbaqus.cxx @@ -0,0 +1,617 @@ +// Scintilla source code edit control +/** @file LexABAQUS.cxx + ** Lexer for ABAQUS. Based on the lexer for APDL by Hadar Raz. + ** By Sergio Lucato. + ** Sort of completely rewritten by Gertjan Kloosterman + **/ +// The License.txt file describes the conditions under which this software may be distributed. + +// Code folding copyied and modified from LexBasic.cxx + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80 && (isalnum(ch) || (ch == '_'))); +} + +static inline bool IsAKeywordChar(const int ch) { + return (ch < 0x80 && (isalnum(ch) || (ch == '_') || (ch == ' '))); +} + +static inline bool IsASetChar(const int ch) { + return (ch < 0x80 && (isalnum(ch) || (ch == '_') || (ch == '.') || (ch == '-'))); +} + +static inline bool IsAnOperator(char ch) { + // '.' left out as it is used to make up numbers + if (ch == '*' || ch == '/' || ch == '-' || ch == '+' || + ch == '(' || ch == ')' || ch == '=' || ch == '^' || + ch == '[' || ch == ']' || ch == '<' || ch == '&' || + ch == '>' || ch == ',' || ch == '|' || ch == '~' || + ch == '$' || ch == ':' || ch == '%') + return true; + return false; +} + +static void ColouriseABAQUSDoc(unsigned int startPos, int length, int initStyle, WordList*[] /* *keywordlists[] */, + Accessor &styler) { + enum localState { KW_LINE_KW, KW_LINE_COMMA, KW_LINE_PAR, KW_LINE_EQ, KW_LINE_VAL, \ + DAT_LINE_VAL, DAT_LINE_COMMA,\ + COMMENT_LINE,\ + ST_ERROR, LINE_END } state ; + + // Do not leak onto next line + state = LINE_END ; + initStyle = SCE_ABAQUS_DEFAULT; + StyleContext sc(startPos, length, initStyle, styler); + + // Things are actually quite simple + // we have commentlines + // keywordlines and datalines + // On a data line there will only be colouring of numbers + // a keyword line is constructed as + // *word,[ paramname[=paramvalue]]* + // if the line ends with a , the keyword line continues onto the new line + + for (; sc.More(); sc.Forward()) { + switch ( state ) { + case KW_LINE_KW : + if ( sc.atLineEnd ) { + // finished the line in keyword state, switch to LINE_END + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } else if ( IsAKeywordChar(sc.ch) ) { + // nothing changes + state = KW_LINE_KW ; + } else if ( sc.ch == ',' ) { + // Well well we say a comma, arguments *MUST* follow + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = KW_LINE_COMMA ; + } else { + // Flag an error + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + // Done with processing + break ; + case KW_LINE_COMMA : + // acomma on a keywordline was seen + if ( IsAKeywordChar(sc.ch)) { + sc.SetState(SCE_ABAQUS_ARGUMENT) ; + state = KW_LINE_PAR ; + } else if ( sc.atLineEnd || (sc.ch == ',') ) { + // we remain in keyword mode + state = KW_LINE_COMMA ; + } else if ( sc.ch == ' ' ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = KW_LINE_COMMA ; + } else { + // Anything else constitutes an error + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + break ; + case KW_LINE_PAR : + if ( sc.atLineEnd ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } else if ( IsAKeywordChar(sc.ch) || (sc.ch == '-') ) { + // remain in this state + state = KW_LINE_PAR ; + } else if ( sc.ch == ',' ) { + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = KW_LINE_COMMA ; + } else if ( sc.ch == '=' ) { + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = KW_LINE_EQ ; + } else { + // Anything else constitutes an error + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + break ; + case KW_LINE_EQ : + if ( sc.ch == ' ' ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + // remain in this state + state = KW_LINE_EQ ; + } else if ( IsADigit(sc.ch) || (sc.ch == '-') || (sc.ch == '.' && IsADigit(sc.chNext)) ) { + sc.SetState(SCE_ABAQUS_NUMBER) ; + state = KW_LINE_VAL ; + } else if ( IsAKeywordChar(sc.ch) ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = KW_LINE_VAL ; + } else if ( (sc.ch == '\'') || (sc.ch == '\"') ) { + sc.SetState(SCE_ABAQUS_STRING) ; + state = KW_LINE_VAL ; + } else { + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + break ; + case KW_LINE_VAL : + if ( sc.atLineEnd ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } else if ( IsASetChar(sc.ch) && (sc.state == SCE_ABAQUS_DEFAULT) ) { + // nothing changes + state = KW_LINE_VAL ; + } else if (( (IsADigit(sc.ch) || sc.ch == '.' || (sc.ch == 'e' || sc.ch == 'E') || + ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E')))) && + (sc.state == SCE_ABAQUS_NUMBER)) { + // remain in number mode + state = KW_LINE_VAL ; + } else if (sc.state == SCE_ABAQUS_STRING) { + // accept everything until a closing quote + if ( sc.ch == '\'' || sc.ch == '\"' ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = KW_LINE_VAL ; + } + } else if ( sc.ch == ',' ) { + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = KW_LINE_COMMA ; + } else { + // anything else is an error + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + break ; + case DAT_LINE_VAL : + if ( sc.atLineEnd ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } else if ( IsASetChar(sc.ch) && (sc.state == SCE_ABAQUS_DEFAULT) ) { + // nothing changes + state = DAT_LINE_VAL ; + } else if (( (IsADigit(sc.ch) || sc.ch == '.' || (sc.ch == 'e' || sc.ch == 'E') || + ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E')))) && + (sc.state == SCE_ABAQUS_NUMBER)) { + // remain in number mode + state = DAT_LINE_VAL ; + } else if (sc.state == SCE_ABAQUS_STRING) { + // accept everything until a closing quote + if ( sc.ch == '\'' || sc.ch == '\"' ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = DAT_LINE_VAL ; + } + } else if ( sc.ch == ',' ) { + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = DAT_LINE_COMMA ; + } else { + // anything else is an error + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + break ; + case DAT_LINE_COMMA : + // a comma on a data line was seen + if ( sc.atLineEnd ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } else if ( sc.ch == ' ' ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = DAT_LINE_COMMA ; + } else if (sc.ch == ',') { + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = DAT_LINE_COMMA ; + } else if ( IsADigit(sc.ch) || (sc.ch == '-')|| (sc.ch == '.' && IsADigit(sc.chNext)) ) { + sc.SetState(SCE_ABAQUS_NUMBER) ; + state = DAT_LINE_VAL ; + } else if ( IsAKeywordChar(sc.ch) ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = DAT_LINE_VAL ; + } else if ( (sc.ch == '\'') || (sc.ch == '\"') ) { + sc.SetState(SCE_ABAQUS_STRING) ; + state = DAT_LINE_VAL ; + } else { + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + break ; + case COMMENT_LINE : + if ( sc.atLineEnd ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } + break ; + case ST_ERROR : + if ( sc.atLineEnd ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = LINE_END ; + } + break ; + case LINE_END : + if ( sc.atLineEnd || sc.ch == ' ' ) { + // nothing changes + state = LINE_END ; + } else if ( sc.ch == '*' ) { + if ( sc.chNext == '*' ) { + state = COMMENT_LINE ; + sc.SetState(SCE_ABAQUS_COMMENT) ; + } else { + state = KW_LINE_KW ; + sc.SetState(SCE_ABAQUS_STARCOMMAND) ; + } + } else { + // it must be a data line, things are as if we are in DAT_LINE_COMMA + if ( sc.ch == ',' ) { + sc.SetState(SCE_ABAQUS_OPERATOR) ; + state = DAT_LINE_COMMA ; + } else if ( IsADigit(sc.ch) || (sc.ch == '-')|| (sc.ch == '.' && IsADigit(sc.chNext)) ) { + sc.SetState(SCE_ABAQUS_NUMBER) ; + state = DAT_LINE_VAL ; + } else if ( IsAKeywordChar(sc.ch) ) { + sc.SetState(SCE_ABAQUS_DEFAULT) ; + state = DAT_LINE_VAL ; + } else if ( (sc.ch == '\'') || (sc.ch == '\"') ) { + sc.SetState(SCE_ABAQUS_STRING) ; + state = DAT_LINE_VAL ; + } else { + sc.SetState(SCE_ABAQUS_PROCESSOR) ; + state = ST_ERROR ; + } + } + break ; + } + } + sc.Complete(); +} + +//------------------------------------------------------------------------------ +// This copyied and modified from LexBasic.cxx +//------------------------------------------------------------------------------ + +/* Bits: + * 1 - whitespace + * 2 - operator + * 4 - identifier + * 8 - decimal digit + * 16 - hex digit + * 32 - bin digit + */ +static int character_classification[128] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, 2, 10, 6, + 60, 60, 28, 28, 28, 28, 28, 28, 28, 28, 2, 2, 2, 2, 2, 2, + 2, 20, 20, 20, 20, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 4, + 2, 20, 20, 20, 20, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0 +}; + +static bool IsSpace(int c) { + return c < 128 && (character_classification[c] & 1); +} + +static bool IsIdentifier(int c) { + return c < 128 && (character_classification[c] & 4); +} + +static int LowerCase(int c) +{ + if (c >= 'A' && c <= 'Z') + return 'a' + c - 'A'; + return c; +} + +static int LineEnd(int line, Accessor &styler) +{ + const int docLines = styler.GetLine(styler.Length() - 1); // Available last line + int eol_pos ; + // if the line is the last line, the eol_pos is styler.Length() + // eol will contain a new line, or a virtual new line + if ( docLines == line ) + eol_pos = styler.Length() ; + else + eol_pos = styler.LineStart(line + 1) - 1; + return eol_pos ; +} + +static int LineStart(int line, Accessor &styler) +{ + return styler.LineStart(line) ; +} + +// LineType +// +// bits determines the line type +// 1 : data line +// 2 : only whitespace +// 3 : data line with only whitespace +// 4 : keyword line +// 5 : block open keyword line +// 6 : block close keyword line +// 7 : keyword line in error +// 8 : comment line +static int LineType(int line, Accessor &styler) { + int pos = LineStart(line, styler) ; + int eol_pos = LineEnd(line, styler) ; + + int c ; + char ch = ' '; + + int i = pos ; + while ( i < eol_pos ) { + c = styler.SafeGetCharAt(i); + ch = static_cast(LowerCase(c)); + // We can say something as soon as no whitespace + // was encountered + if ( !IsSpace(c) ) + break ; + i++ ; + } + + if ( i >= eol_pos ) { + // This is a whitespace line, currently + // classifies as data line + return 3 ; + } + + if ( ch != '*' ) { + // This is a data line + return 1 ; + } + + if ( i == eol_pos - 1 ) { + // Only a single *, error but make keyword line + return 4+3 ; + } + + // This means we can have a second character + // if that is also a * this means a comment + // otherwise it is a keyword. + c = styler.SafeGetCharAt(i+1); + ch = static_cast(LowerCase(c)); + if ( ch == '*' ) { + return 8 ; + } + + // At this point we know this is a keyword line + // the character at position i is a * + // it is not a comment line + char word[256] ; + int wlen = 0; + + word[wlen] = '*' ; + wlen++ ; + + i++ ; + while ( (i < eol_pos) && (wlen < 255) ) { + c = styler.SafeGetCharAt(i); + ch = static_cast(LowerCase(c)); + + if ( (!IsSpace(c)) && (!IsIdentifier(c)) ) + break ; + + if ( IsIdentifier(c) ) { + word[wlen] = ch ; + wlen++ ; + } + + i++ ; + } + + word[wlen] = 0 ; + + // Make a comparison + if ( !strcmp(word, "*step") || + !strcmp(word, "*part") || + !strcmp(word, "*instance") || + !strcmp(word, "*assembly")) { + return 4+1 ; + } + + if ( !strcmp(word, "*endstep") || + !strcmp(word, "*endpart") || + !strcmp(word, "*endinstance") || + !strcmp(word, "*endassembly")) { + return 4+2 ; + } + + return 4 ; +} + +static void SafeSetLevel(int line, int level, Accessor &styler) +{ + if ( line < 0 ) + return ; + + int mask = ((~SC_FOLDLEVELHEADERFLAG) | (~SC_FOLDLEVELWHITEFLAG)); + + if ( (level & mask) < 0 ) + return ; + + if ( styler.LevelAt(line) != level ) + styler.SetLevel(line, level) ; +} + +static void FoldABAQUSDoc(unsigned int startPos, int length, int, +WordList *[], Accessor &styler) { + int startLine = styler.GetLine(startPos) ; + int endLine = styler.GetLine(startPos+length-1) ; + + // bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + // We want to deal with all the cases + // To know the correct indentlevel, we need to look back to the + // previous command line indentation level + // order of formatting keyline datalines commentlines + int beginData = -1 ; + int beginComment = -1 ; + int prvKeyLine = startLine ; + int prvKeyLineTp = 0 ; + + // Scan until we find the previous keyword line + // this will give us the level reference that we need + while ( prvKeyLine > 0 ) { + prvKeyLine-- ; + prvKeyLineTp = LineType(prvKeyLine, styler) ; + if ( prvKeyLineTp & 4 ) + break ; + } + + // Determine the base line level of all lines following + // the previous keyword + // new keyword lines are placed on this level + //if ( prvKeyLineTp & 4 ) { + int level = styler.LevelAt(prvKeyLine) & ~SC_FOLDLEVELHEADERFLAG ; + //} + + // uncomment line below if weird behaviour continues + prvKeyLine = -1 ; + + // Now start scanning over the lines. + for ( int line = startLine; line <= endLine; line++ ) { + int lineType = LineType(line, styler) ; + + // Check for comment line + if ( lineType == 8 ) { + if ( beginComment < 0 ) { + beginComment = line ; + } + } + + // Check for data line + if ( (lineType == 1) || (lineType == 3) ) { + if ( beginData < 0 ) { + if ( beginComment >= 0 ) { + beginData = beginComment ; + } else { + beginData = line ; + } + } + beginComment = -1 ; + } + + // Check for keywordline. + // As soon as a keyword line is encountered, we can set the + // levels of everything from the previous keyword line to this one + if ( lineType & 4 ) { + // this is a keyword, we can now place the previous keyword + // all its data lines and the remainder + + // Write comments and data line + if ( beginComment < 0 ) { + beginComment = line ; + } + + if ( beginData < 0 ) { + beginData = beginComment ; + if ( prvKeyLineTp != 5 ) + SafeSetLevel(prvKeyLine, level, styler) ; + else + SafeSetLevel(prvKeyLine, level | SC_FOLDLEVELHEADERFLAG, styler) ; + } else { + SafeSetLevel(prvKeyLine, level | SC_FOLDLEVELHEADERFLAG, styler) ; + } + + int datLevel = level + 1 ; + if ( !(prvKeyLineTp & 4) ) { + datLevel = level ; + } + + for ( int ll = beginData; ll < beginComment; ll++ ) + SafeSetLevel(ll, datLevel, styler) ; + + // The keyword we just found is going to be written at another level + // if we have a type 5 and type 6 + if ( prvKeyLineTp == 5 ) { + level += 1 ; + } + + if ( prvKeyLineTp == 6 ) { + level -= 1 ; + if ( level < 0 ) { + level = 0 ; + } + } + + for ( int lll = beginComment; lll < line; lll++ ) + SafeSetLevel(lll, level, styler) ; + + // wrap and reset + beginComment = -1 ; + beginData = -1 ; + prvKeyLine = line ; + prvKeyLineTp = lineType ; + } + + } + + if ( beginComment < 0 ) { + beginComment = endLine + 1 ; + } else { + // We need to find out whether this comment block is followed by + // a data line or a keyword line + const int docLines = styler.GetLine(styler.Length() - 1); + + for ( int line = endLine + 1; line <= docLines; line++ ) { + int lineType = LineType(line, styler) ; + + if ( lineType != 8 ) { + if ( !(lineType & 4) ) { + beginComment = endLine + 1 ; + } + break ; + } + } + } + + if ( beginData < 0 ) { + beginData = beginComment ; + if ( prvKeyLineTp != 5 ) + SafeSetLevel(prvKeyLine, level, styler) ; + else + SafeSetLevel(prvKeyLine, level | SC_FOLDLEVELHEADERFLAG, styler) ; + } else { + SafeSetLevel(prvKeyLine, level | SC_FOLDLEVELHEADERFLAG, styler) ; + } + + int datLevel = level + 1 ; + if ( !(prvKeyLineTp & 4) ) { + datLevel = level ; + } + + for ( int ll = beginData; ll < beginComment; ll++ ) + SafeSetLevel(ll, datLevel, styler) ; + + if ( prvKeyLineTp == 5 ) { + level += 1 ; + } + + if ( prvKeyLineTp == 6 ) { + level -= 1 ; + } + for ( int m = beginComment; m <= endLine; m++ ) + SafeSetLevel(m, level, styler) ; +} + +static const char * const abaqusWordListDesc[] = { + "processors", + "commands", + "slashommands", + "starcommands", + "arguments", + "functions", + 0 +}; + +LexerModule lmAbaqus(SCLEX_ABAQUS, ColouriseABAQUSDoc, "abaqus", FoldABAQUSDoc, abaqusWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexAda.cxx b/sdk/wxscintilla/src/scintilla/src/LexAda.cxx new file mode 100644 index 0000000..654bfbe --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAda.cxx @@ -0,0 +1,525 @@ +// Scintilla source code edit control +/** @file LexAda.cxx + ** Lexer for Ada 95 + **/ +// Copyright 2002 by Sergey Koshcheyev +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include + +#include + +#include "Platform.h" + +#include "Accessor.h" +#include "StyleContext.h" +#include "PropSet.h" +#include "KeyWords.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +/* + * Interface + */ + +static void ColouriseDocument( + unsigned int startPos, + int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler); + +static const char * const adaWordListDesc[] = { + "Keywords", + 0 +}; + +LexerModule lmAda(SCLEX_ADA, ColouriseDocument, "ada", NULL, adaWordListDesc); + +/* + * Implementation + */ + +// Functions that have apostropheStartsAttribute as a parameter set it according to whether +// an apostrophe encountered after processing the current token will start an attribute or +// a character literal. +static void ColouriseCharacter(StyleContext& sc, bool& apostropheStartsAttribute); +static void ColouriseComment(StyleContext& sc, bool& apostropheStartsAttribute); +static void ColouriseContext(StyleContext& sc, char chEnd, int stateEOL); +static void ColouriseDelimiter(StyleContext& sc, bool& apostropheStartsAttribute); +static void ColouriseLabel(StyleContext& sc, WordList& keywords, bool& apostropheStartsAttribute); +static void ColouriseNumber(StyleContext& sc, bool& apostropheStartsAttribute); +static void ColouriseString(StyleContext& sc, bool& apostropheStartsAttribute); +static void ColouriseWhiteSpace(StyleContext& sc, bool& apostropheStartsAttribute); +static void ColouriseWord(StyleContext& sc, WordList& keywords, bool& apostropheStartsAttribute); + +static inline bool IsDelimiterCharacter(int ch); +static inline bool IsNumberStartCharacter(int ch); +static inline bool IsNumberCharacter(int ch); +static inline bool IsSeparatorOrDelimiterCharacter(int ch); +static bool IsValidIdentifier(const std::string& identifier); +static bool IsValidNumber(const std::string& number); +static inline bool IsWordStartCharacter(int ch); +static inline bool IsWordCharacter(int ch); + +static void ColouriseCharacter(StyleContext& sc, bool& apostropheStartsAttribute) { + apostropheStartsAttribute = true; + + sc.SetState(SCE_ADA_CHARACTER); + + // Skip the apostrophe and one more character (so that '' is shown as non-terminated and ''' + // is handled correctly) + sc.Forward(); + sc.Forward(); + + ColouriseContext(sc, '\'', SCE_ADA_CHARACTEREOL); +} + +static void ColouriseContext(StyleContext& sc, char chEnd, int stateEOL) { + while (!sc.atLineEnd && !sc.Match(chEnd)) { + sc.Forward(); + } + + if (!sc.atLineEnd) { + sc.ForwardSetState(SCE_ADA_DEFAULT); + } else { + sc.ChangeState(stateEOL); + } +} + +static void ColouriseComment(StyleContext& sc, bool& /*apostropheStartsAttribute*/) { + // Apostrophe meaning is not changed, but the parameter is present for uniformity + + sc.SetState(SCE_ADA_COMMENTLINE); + + while (!sc.atLineEnd) { + sc.Forward(); + } +} + +static void ColouriseDelimiter(StyleContext& sc, bool& apostropheStartsAttribute) { + apostropheStartsAttribute = sc.Match (')'); + sc.SetState(SCE_ADA_DELIMITER); + sc.ForwardSetState(SCE_ADA_DEFAULT); +} + +static void ColouriseLabel(StyleContext& sc, WordList& keywords, bool& apostropheStartsAttribute) { + apostropheStartsAttribute = false; + + sc.SetState(SCE_ADA_LABEL); + + // Skip "<<" + sc.Forward(); + sc.Forward(); + + std::string identifier; + + while (!sc.atLineEnd && !IsSeparatorOrDelimiterCharacter(sc.ch)) { + identifier += static_cast(tolower(sc.ch)); + sc.Forward(); + } + + // Skip ">>" + if (sc.Match('>', '>')) { + sc.Forward(); + sc.Forward(); + } else { + sc.ChangeState(SCE_ADA_ILLEGAL); + } + + // If the name is an invalid identifier or a keyword, then make it invalid label + if (!IsValidIdentifier(identifier) || keywords.InList(identifier.c_str())) { + sc.ChangeState(SCE_ADA_ILLEGAL); + } + + sc.SetState(SCE_ADA_DEFAULT); + +} + +static void ColouriseNumber(StyleContext& sc, bool& apostropheStartsAttribute) { + apostropheStartsAttribute = true; + + std::string number; + sc.SetState(SCE_ADA_NUMBER); + + // Get all characters up to a delimiter or a separator, including points, but excluding + // double points (ranges). + while (!IsSeparatorOrDelimiterCharacter(sc.ch) || (sc.ch == '.' && sc.chNext != '.')) { + number += static_cast(sc.ch); + sc.Forward(); + } + + // Special case: exponent with sign + if ((sc.chPrev == 'e' || sc.chPrev == 'E') && + (sc.ch == '+' || sc.ch == '-')) { + number += static_cast(sc.ch); + sc.Forward (); + + while (!IsSeparatorOrDelimiterCharacter(sc.ch)) { + number += static_cast(sc.ch); + sc.Forward(); + } + } + + if (!IsValidNumber(number)) { + sc.ChangeState(SCE_ADA_ILLEGAL); + } + + sc.SetState(SCE_ADA_DEFAULT); +} + +static void ColouriseString(StyleContext& sc, bool& apostropheStartsAttribute) { + apostropheStartsAttribute = true; + + sc.SetState(SCE_ADA_STRING); + sc.Forward(); + + ColouriseContext(sc, '"', SCE_ADA_STRINGEOL); +} + +static void ColouriseWhiteSpace(StyleContext& sc, bool& /*apostropheStartsAttribute*/) { + // Apostrophe meaning is not changed, but the parameter is present for uniformity + sc.SetState(SCE_ADA_DEFAULT); + sc.ForwardSetState(SCE_ADA_DEFAULT); +} + +static void ColouriseWord(StyleContext& sc, WordList& keywords, bool& apostropheStartsAttribute) { + apostropheStartsAttribute = true; + sc.SetState(SCE_ADA_IDENTIFIER); + + std::string word; + + while (!sc.atLineEnd && !IsSeparatorOrDelimiterCharacter(sc.ch)) { + word += static_cast(tolower(sc.ch)); + sc.Forward(); + } + + if (!IsValidIdentifier(word)) { + sc.ChangeState(SCE_ADA_ILLEGAL); + + } else if (keywords.InList(word.c_str())) { + sc.ChangeState(SCE_ADA_WORD); + + if (word != "all") { + apostropheStartsAttribute = false; + } + } + + sc.SetState(SCE_ADA_DEFAULT); +} + +// +// ColouriseDocument +// + +static void ColouriseDocument( + unsigned int startPos, + int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler) { + WordList &keywords = *keywordlists[0]; + + StyleContext sc(startPos, length, initStyle, styler); + + int lineCurrent = styler.GetLine(startPos); + bool apostropheStartsAttribute = (styler.GetLineState(lineCurrent) & 1) != 0; + + while (sc.More()) { + if (sc.atLineEnd) { + // Go to the next line + sc.Forward(); + lineCurrent++; + + // Remember the line state for future incremental lexing + styler.SetLineState(lineCurrent, apostropheStartsAttribute); + + // Don't continue any styles on the next line + sc.SetState(SCE_ADA_DEFAULT); + } + + // Comments + if (sc.Match('-', '-')) { + ColouriseComment(sc, apostropheStartsAttribute); + + // Strings + } else if (sc.Match('"')) { + ColouriseString(sc, apostropheStartsAttribute); + + // Characters + } else if (sc.Match('\'') && !apostropheStartsAttribute) { + ColouriseCharacter(sc, apostropheStartsAttribute); + + // Labels + } else if (sc.Match('<', '<')) { + ColouriseLabel(sc, keywords, apostropheStartsAttribute); + + // Whitespace + } else if (IsASpace(sc.ch)) { + ColouriseWhiteSpace(sc, apostropheStartsAttribute); + + // Delimiters + } else if (IsDelimiterCharacter(sc.ch)) { + ColouriseDelimiter(sc, apostropheStartsAttribute); + + // Numbers + } else if (IsADigit(sc.ch) || sc.ch == '#') { + ColouriseNumber(sc, apostropheStartsAttribute); + + // Keywords or identifiers + } else { + ColouriseWord(sc, keywords, apostropheStartsAttribute); + } + } + + sc.Complete(); +} + +static inline bool IsDelimiterCharacter(int ch) { + switch (ch) { + case '&': + case '\'': + case '(': + case ')': + case '*': + case '+': + case ',': + case '-': + case '.': + case '/': + case ':': + case ';': + case '<': + case '=': + case '>': + case '|': + return true; + default: + return false; + } +} + +static inline bool IsNumberCharacter(int ch) { + return IsNumberStartCharacter(ch) || + ch == '_' || + ch == '.' || + ch == '#' || + (ch >= 'a' && ch <= 'f') || + (ch >= 'A' && ch <= 'F'); +} + +static inline bool IsNumberStartCharacter(int ch) { + return IsADigit(ch); +} + +static inline bool IsSeparatorOrDelimiterCharacter(int ch) { + return IsASpace(ch) || IsDelimiterCharacter(ch); +} + +static bool IsValidIdentifier(const std::string& identifier) { + // First character can't be '_', so initialize the flag to true + bool lastWasUnderscore = true; + + size_t length = identifier.length(); + + // Zero-length identifiers are not valid (these can occur inside labels) + if (length == 0) { + return false; + } + + // Check for valid character at the start + if (!IsWordStartCharacter(identifier[0])) { + return false; + } + + // Check for only valid characters and no double underscores + for (size_t i = 0; i < length; i++) { + if (!IsWordCharacter(identifier[i]) || + (identifier[i] == '_' && lastWasUnderscore)) { + return false; + } + lastWasUnderscore = identifier[i] == '_'; + } + + // Check for underscore at the end + if (lastWasUnderscore == true) { + return false; + } + + // All checks passed + return true; +} + +static bool IsValidNumber(const std::string& number) { + size_t hashPos = number.find("#"); + bool seenDot = false; + + size_t i = 0; + size_t length = number.length(); + + if (length == 0) + return false; // Just in case + + // Decimal number + if (hashPos == std::string::npos) { + bool canBeSpecial = false; + + for (; i < length; i++) { + if (number[i] == '_') { + if (!canBeSpecial) { + return false; + } + canBeSpecial = false; + } else if (number[i] == '.') { + if (!canBeSpecial || seenDot) { + return false; + } + canBeSpecial = false; + seenDot = true; + } else if (IsADigit(number[i])) { + canBeSpecial = true; + } else { + break; + } + } + + if (!canBeSpecial) + return false; + } else { + // Based number + bool canBeSpecial = false; + int base = 0; + + // Parse base + for (; i < length; i++) { + int ch = number[i]; + if (ch == '_') { + if (!canBeSpecial) + return false; + canBeSpecial = false; + } else if (IsADigit(ch)) { + base = base * 10 + (ch - '0'); + if (base > 16) + return false; + canBeSpecial = true; + } else if (ch == '#' && canBeSpecial) { + break; + } else { + return false; + } + } + + if (base < 2) + return false; + if (i == length) + return false; + + i++; // Skip over '#' + + // Parse number + canBeSpecial = false; + + for (; i < length; i++) { + int ch = tolower(number[i]); + + if (ch == '_') { + if (!canBeSpecial) { + return false; + } + canBeSpecial = false; + + } else if (ch == '.') { + if (!canBeSpecial || seenDot) { + return false; + } + canBeSpecial = false; + seenDot = true; + + } else if (IsADigit(ch)) { + if (ch - '0' >= base) { + return false; + } + canBeSpecial = true; + + } else if (ch >= 'a' && ch <= 'f') { + if (ch - 'a' + 10 >= base) { + return false; + } + canBeSpecial = true; + + } else if (ch == '#' && canBeSpecial) { + break; + + } else { + return false; + } + } + + if (i == length) { + return false; + } + + i++; + } + + // Exponent (optional) + if (i < length) { + if (number[i] != 'e' && number[i] != 'E') + return false; + + i++; // Move past 'E' + + if (i == length) { + return false; + } + + if (number[i] == '+') + i++; + else if (number[i] == '-') { + if (seenDot) { + i++; + } else { + return false; // Integer literals should not have negative exponents + } + } + + if (i == length) { + return false; + } + + bool canBeSpecial = false; + + for (; i < length; i++) { + if (number[i] == '_') { + if (!canBeSpecial) { + return false; + } + canBeSpecial = false; + } else if (IsADigit(number[i])) { + canBeSpecial = true; + } else { + return false; + } + } + + if (!canBeSpecial) + return false; + } + + // if i == length, number was parsed successfully. + return i == length; +} + +static inline bool IsWordCharacter(int ch) { + return IsWordStartCharacter(ch) || IsADigit(ch); +} + +static inline bool IsWordStartCharacter(int ch) { + return (isascii(ch) && isalpha(ch)) || ch == '_'; +} diff --git a/sdk/wxscintilla/src/scintilla/src/LexAltaRica.cxx b/sdk/wxscintilla/src/scintilla/src/LexAltaRica.cxx new file mode 100644 index 0000000..b77647e --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAltaRica.cxx @@ -0,0 +1,412 @@ +// Scintilla source code edit control +/** @file LexAltaRica.cxx + ** Lexers for the AltaRica language. + **/ +// Copyright 2010 by Florent Teichteil-Königsbuch +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "CharacterSet.h" +#include "CharClassify.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool isAltaRicaOperator(char ch) { + if (isascii(ch) && isalnum(ch)) + return false; + + if ((ch == '?') || (ch == '{') || (ch == '}') || (ch == '<') || (ch == '>') || + (ch == '=') || (ch == '|') || (ch == '&') || (ch == ';') || (ch == ',') || + (ch == '.') || (ch == '(') || (ch == ')') || (ch == '[') || (ch == ']') || + (ch == '+') || (ch == '-') || (ch == '*') || (ch == '~') || (ch == '/') || + (ch == '!') || (ch == ':')) + return true; + + return false; +} + +static inline bool isAltaRicaForbidden(char ch) { + return !isascii(ch) || (ch == '\"') || (ch == '#') || (ch == '$') || (ch == '%') || + (ch == '\'') || (ch == '@') || (ch == '^') || (ch == '`'); +} + +static inline bool isAltaRicaWordStart(char ch) { + return isascii(ch) && !isspacechar(ch) && !isAltaRicaOperator(ch) && + !isAltaRicaForbidden(ch) && (ch != '\n') && (ch != '\r'); +} + +static void classifyWordAltaRica(unsigned int start, unsigned int end, WordList &keywords, + WordList &types, Accessor &styler) { + PLATFORM_ASSERT(end >= start); + char s[100]; + + for (unsigned int i = 0; (i < end - start + 1) && (i < 99); i++) { + s[i] = MakeUpperCase(styler[start + i]); + s[i + 1] = '\0'; + } + + if (keywords.InList(s)) + styler.ColourTo(end, SCE_ALTARICA_KEYWORD); + else if (types.InList(s)) + styler.ColourTo(end, SCE_ALTARICA_TYPE); + else + styler.ColourTo(end, SCE_ALTARICA_IDENTIFIER); +} + +static void ColouriseAltaRicaDoc( + unsigned int startPos, + int length, + int initStyle, + WordList* keywordlists[], + Accessor& styler) +{ + WordList &keywords = *keywordlists[0]; + WordList &types = *keywordlists[1]; + + styler.StartAt(startPos); + + int state = initStyle; + char chNext = styler[startPos]; + unsigned int lengthDoc = startPos + length; + styler.StartSegment(startPos); + + for (unsigned int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + + if (styler.IsLeadByte(ch)) { + chNext = styler.SafeGetCharAt(i + 2); + i += 1; + continue; + } + + if (state == SCE_ALTARICA_DEFAULT) { + if ((ch == '/') && (chNext == '/')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i - 2, state); + state = SCE_ALTARICA_COMMENTLINE; + } + else if ((ch == '/') && (chNext == '*')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i - 2, state); + state = SCE_ALTARICA_COMMENT; + } + else if (isAltaRicaOperator(ch)) { + styler.ColourTo(i - 1, state); + styler.ColourTo(i, SCE_ALTARICA_OPERATOR); + } + else if (isAltaRicaWordStart(ch) && !isdigit(ch)) { + styler.ColourTo(i - 1, state); + state = SCE_ALTARICA_IDENTIFIER; + } + else if (isdigit(ch)) { + styler.ColourTo(i - 1, state); + state = SCE_ALTARICA_NUMBER; + } + else if (isAltaRicaForbidden(ch)) { + styler.ColourTo(i - 1, state); + styler.ColourTo(i, SCE_ALTARICA_FORBIDDEN); + } + } + else if (state == SCE_ALTARICA_COMMENTLINE) { + if (atEOL) { + styler.ColourTo(i - 1, state); + state = SCE_ALTARICA_DEFAULT; + } + } + else if (state == SCE_ALTARICA_COMMENT) { + if ((ch == '*') && (chNext == '/')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i, state); + state = SCE_ALTARICA_DEFAULT; + } + } + else if (state == SCE_ALTARICA_IDENTIFIER) { + if (!isAltaRicaWordStart(ch)) { + classifyWordAltaRica(styler.GetStartSegment(), i - 1, keywords, types, styler); + + if ((ch == '/') && (chNext == '/')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i - 2, state); + state = SCE_ALTARICA_COMMENTLINE; + } + else if ((ch == '/') && (chNext == '*')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i - 2, state); + state = SCE_ALTARICA_COMMENT; + } + else if (isAltaRicaOperator(ch)) { + styler.ColourTo(i - 1, state); + styler.ColourTo(i, SCE_ALTARICA_OPERATOR); + state = SCE_ALTARICA_DEFAULT; + } + else if (isAltaRicaForbidden(ch)) { + styler.ColourTo(i - 1, state); + styler.ColourTo(i, SCE_ALTARICA_FORBIDDEN); + state = SCE_ALTARICA_DEFAULT; + } + else + state = SCE_ALTARICA_DEFAULT; + } + } + else if (state == SCE_ALTARICA_NUMBER) { + if (!isdigit(ch)) { + styler.ColourTo(i - 1, state); + + if ((ch == '/') && (chNext == '/')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i - 2, state); + state = SCE_ALTARICA_COMMENTLINE; + } + else if ((ch == '/') && (chNext == '*')) { + i++; + chNext = styler.SafeGetCharAt(i + 1); + styler.ColourTo(i - 2, state); + state = SCE_ALTARICA_COMMENT; + } + else if (isAltaRicaOperator(ch)) { + styler.ColourTo(i - 1, state); + styler.ColourTo(i, SCE_ALTARICA_OPERATOR); + state = SCE_ALTARICA_DEFAULT; + } + else if (isAltaRicaForbidden(ch)) { + styler.ColourTo(i, SCE_ALTARICA_FORBIDDEN); + state = SCE_ALTARICA_DEFAULT; + } + else + state = SCE_ALTARICA_DEFAULT; + } + } + } + + styler.ColourTo(lengthDoc - 1, state); +} + +static bool IsCommentLine(int line, Accessor& styler) { + unsigned int pos = styler.LineStart(line); + unsigned int eol_pos = styler.LineStart(line + 1) - 1; + if (pos == eol_pos) { + int style = styler.StyleAt(pos); + return (style == SCE_ALTARICA_COMMENT); + } + for (unsigned int i = pos; i < eol_pos; i++) { + int style = styler.StyleAt(i); + if (style == SCE_ALTARICA_COMMENTLINE) + return true; + else if (style == SCE_ALTARICA_COMMENT) { + if (i+1 == eol_pos) { + return true; + } + } else { + char ch = styler[i]; + if ((ch != ' ') && (ch != '\t')) { + return false; + } + } + } + return false; +} + +static bool PreviousFoldKeywordIsInsideNode(unsigned int endPos, Accessor& styler) { + unsigned int pos = endPos; + bool wordEnd = false; + unsigned int posWordEnd = 0; + char s[10]; // AltaRica keywords have atmost 9 characters + while (pos > 0) { + int style = styler.StyleAt(pos-1); + if (!wordEnd && (style == SCE_ALTARICA_KEYWORD)) { + posWordEnd = pos; + wordEnd = true; + } + else if (wordEnd && ((style != SCE_ALTARICA_KEYWORD) || (pos == 1))) { + if (style == SCE_ALTARICA_KEYWORD) { // keyword begins at position 0 + pos--; + } + for (unsigned int i = 0; i < posWordEnd - pos && i < 9; i++) { // AltaRica keywords have atmost 9 characters + s[i] = static_cast(styler[ pos + i ]); + s[i + 1] = '\0'; + } + if ((CompareCaseInsensitive(s, "node") == 0) || + (CompareCaseInsensitive(s, "edon") == 0) || + (CompareCaseInsensitive(s, "struct") == 0) || + (CompareCaseInsensitive(s, "tcurts") == 0) || + (CompareCaseInsensitive(s, "domain") == 0) || + (CompareCaseInsensitive(s, "const") == 0)) { + return false; + } + else if ((CompareCaseInsensitive(s, "sub") == 0) || + (CompareCaseInsensitive(s, "flow") == 0) || + (CompareCaseInsensitive(s, "state") == 0) || + (CompareCaseInsensitive(s, "event") == 0) || + (CompareCaseInsensitive(s, "trans") == 0) || + (CompareCaseInsensitive(s, "assert") == 0) || + (CompareCaseInsensitive(s, "init") == 0)) { + return true; + } else { // not a fold keyword so continue searching backward + wordEnd = false; + } + } + pos--; + } + return false; +} + +static bool NextLineIsFoldKeyword(int line, Accessor& styler) { + unsigned int pos = styler.LineStart(line + 1); + unsigned int eol_pos = styler.LineStart(line + 2) - 1; + bool wordStart = false; + unsigned int posWordStart = 0; + char s[10]; // AltaRica keywords have atmost 9 characters + for (unsigned int i = pos; i <= eol_pos; i++) { + int style = styler.StyleAt(i); + if (!wordStart && (style == SCE_ALTARICA_KEYWORD)) { + posWordStart = i; + wordStart = true; + } + else if (wordStart && ((style != SCE_ALTARICA_KEYWORD) || (i == eol_pos))) { + for (unsigned int j = 0; j < i - posWordStart && j < 9; j++) { // AltaRica keywords have atmost 9 characters + s[j] = static_cast(styler[ posWordStart + j ]); + s[j + 1] = '\0'; + } + if ((CompareCaseInsensitive(s, "node") == 0) || + (CompareCaseInsensitive(s, "edon") == 0) || + (CompareCaseInsensitive(s, "struct") == 0) || + (CompareCaseInsensitive(s, "tcurts") == 0) || + (CompareCaseInsensitive(s, "sub") == 0) || + (CompareCaseInsensitive(s, "flow") == 0) || + (CompareCaseInsensitive(s, "state") == 0) || + (CompareCaseInsensitive(s, "event") == 0) || + (CompareCaseInsensitive(s, "trans") == 0) || + (CompareCaseInsensitive(s, "assert") == 0) || + (CompareCaseInsensitive(s, "init") == 0) || + (CompareCaseInsensitive(s, "domain") == 0) || + (CompareCaseInsensitive(s, "const") == 0)) { + return true; + } + else + return false; + } + else if(!wordStart) { + char ch = styler[i]; + if ((ch != ' ') && (ch != '\t')) { + return false; + } + } + } + return false; +} + +static void FoldAltaRicaDoc(unsigned int startPos, int length, int initStyle, + WordList* keywordlists[], Accessor& styler) { + if (styler.GetPropertyInt("fold") == 0) return; + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + unsigned int endPos = startPos + length; + char chNext = styler[startPos]; + bool wordStart = false; + unsigned int posWordStart = 0; + char altaricaKeyword[10]; // AltaRica keywords have atmost 9 characters + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int style = styler.StyleAt(i); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (!wordStart && (style == SCE_ALTARICA_KEYWORD)) { + posWordStart = i; + wordStart = true; + } + else if (wordStart && (style != SCE_ALTARICA_KEYWORD)) { + for (unsigned int j = 0; j < i - posWordStart && j < 9; j++) { // AltaRica keywords have atmost 9 characters + altaricaKeyword[j] = static_cast(styler[ posWordStart + j ]); + altaricaKeyword[j + 1] = '\0'; + } + if (CompareCaseInsensitive(altaricaKeyword, "node") == 0) { + levelCurrent++; + } + else if (CompareCaseInsensitive(altaricaKeyword, "edon") == 0) { + levelCurrent--; + } + else if (CompareCaseInsensitive(altaricaKeyword, "struct") == 0) { + levelCurrent++; + } + else if (CompareCaseInsensitive(altaricaKeyword, "tcurts") == 0) { + levelCurrent--; + } + else if ((CompareCaseInsensitive(altaricaKeyword, "sub") == 0) || + (CompareCaseInsensitive(altaricaKeyword, "flow") == 0) || + (CompareCaseInsensitive(altaricaKeyword, "state") == 0) || + (CompareCaseInsensitive(altaricaKeyword, "event") == 0) || + (CompareCaseInsensitive(altaricaKeyword, "trans") == 0) || + (CompareCaseInsensitive(altaricaKeyword, "assert") == 0) || + (CompareCaseInsensitive(altaricaKeyword, "init") == 0)) { + levelCurrent++; + } + wordStart = false; + } + if (atEOL) { + // Comment folding + if (foldComment && IsCommentLine(lineCurrent, styler)) { + if (((lineCurrent == 0) || !IsCommentLine(lineCurrent - 1, styler)) + && IsCommentLine(lineCurrent + 1, styler)) + levelCurrent++; + else if ((lineCurrent > 0) && IsCommentLine(lineCurrent - 1, styler) + && !IsCommentLine(lineCurrent + 1, styler)) + levelCurrent--; + } + else if (NextLineIsFoldKeyword(lineCurrent, styler) && PreviousFoldKeywordIsInsideNode(i, styler)) { + levelCurrent--; + } + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) + visibleChars++; + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +static const char * const altaricaWordListDesc[] = { + "keywords", + "types", + 0, +}; + +LexerModule lmAltaRica(SCLEX_ALTARICA, ColouriseAltaRicaDoc, "altarica", FoldAltaRicaDoc, altaricaWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexAsm.cxx b/sdk/wxscintilla/src/scintilla/src/LexAsm.cxx new file mode 100644 index 0000000..17c9384 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAsm.cxx @@ -0,0 +1,180 @@ +// Scintilla source code edit control +/** @file LexAsm.cxx + ** Lexer for Assembler, just for the MASM syntax + ** Written by The Black Horus + ** Enhancements and NASM stuff by Kein-Hong Man, 2003-10 + ** SCE_ASM_COMMENTBLOCK and SCE_ASM_CHARACTER are for future GNU as colouring + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' || + ch == '_' || ch == '?'); +} + +static inline bool IsAWordStart(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' || + ch == '%' || ch == '@' || ch == '$' || ch == '?'); +} + +static inline bool IsAsmOperator(const int ch) { + if ((ch < 0x80) && (isalnum(ch))) + return false; + // '.' left out as it is used to make up numbers + if (ch == '*' || ch == '/' || ch == '-' || ch == '+' || + ch == '(' || ch == ')' || ch == '=' || ch == '^' || + ch == '[' || ch == ']' || ch == '<' || ch == '&' || + ch == '>' || ch == ',' || ch == '|' || ch == '~' || + ch == '%' || ch == ':') + return true; + return false; +} + +static void ColouriseAsmDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + + WordList &cpuInstruction = *keywordlists[0]; + WordList &mathInstruction = *keywordlists[1]; + WordList ®isters = *keywordlists[2]; + WordList &directive = *keywordlists[3]; + WordList &directiveOperand = *keywordlists[4]; + WordList &extInstruction = *keywordlists[5]; + + // Do not leak onto next line + if (initStyle == SCE_ASM_STRINGEOL) + initStyle = SCE_ASM_DEFAULT; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) + { + + // Prevent SCE_ASM_STRINGEOL from leaking back to previous line + if (sc.atLineStart && (sc.state == SCE_ASM_STRING)) { + sc.SetState(SCE_ASM_STRING); + } else if (sc.atLineStart && (sc.state == SCE_ASM_CHARACTER)) { + sc.SetState(SCE_ASM_CHARACTER); + } + + // Handle line continuation generically. + if (sc.ch == '\\') { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + continue; + } + } + + // Determine if the current state should terminate. + if (sc.state == SCE_ASM_OPERATOR) { + if (!IsAsmOperator(sc.ch)) { + sc.SetState(SCE_ASM_DEFAULT); + } + }else if (sc.state == SCE_ASM_NUMBER) { + if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_ASM_DEFAULT); + } + } else if (sc.state == SCE_ASM_IDENTIFIER) { + if (!IsAWordChar(sc.ch) ) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + + if (cpuInstruction.InList(s)) { + sc.ChangeState(SCE_ASM_CPUINSTRUCTION); + } else if (mathInstruction.InList(s)) { + sc.ChangeState(SCE_ASM_MATHINSTRUCTION); + } else if (registers.InList(s)) { + sc.ChangeState(SCE_ASM_REGISTER); + } else if (directive.InList(s)) { + sc.ChangeState(SCE_ASM_DIRECTIVE); + } else if (directiveOperand.InList(s)) { + sc.ChangeState(SCE_ASM_DIRECTIVEOPERAND); + } else if (extInstruction.InList(s)) { + sc.ChangeState(SCE_ASM_EXTINSTRUCTION); + } + sc.SetState(SCE_ASM_DEFAULT); + } + } + else if (sc.state == SCE_ASM_COMMENT ) { + if (sc.atLineEnd) { + sc.SetState(SCE_ASM_DEFAULT); + } + } else if (sc.state == SCE_ASM_STRING) { + if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\"') { + sc.ForwardSetState(SCE_ASM_DEFAULT); + } else if (sc.atLineEnd) { + sc.ChangeState(SCE_ASM_STRINGEOL); + sc.ForwardSetState(SCE_ASM_DEFAULT); + } + } else if (sc.state == SCE_ASM_CHARACTER) { + if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\'') { + sc.ForwardSetState(SCE_ASM_DEFAULT); + } else if (sc.atLineEnd) { + sc.ChangeState(SCE_ASM_STRINGEOL); + sc.ForwardSetState(SCE_ASM_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_ASM_DEFAULT) { + if (sc.ch == ';'){ + sc.SetState(SCE_ASM_COMMENT); + } else if (isascii(sc.ch) && (isdigit(sc.ch) || (sc.ch == '.' && isascii(sc.chNext) && isdigit(sc.chNext)))) { + sc.SetState(SCE_ASM_NUMBER); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_ASM_IDENTIFIER); + } else if (sc.ch == '\"') { + sc.SetState(SCE_ASM_STRING); + } else if (sc.ch == '\'') { + sc.SetState(SCE_ASM_CHARACTER); + } else if (IsAsmOperator(sc.ch)) { + sc.SetState(SCE_ASM_OPERATOR); + } + } + + } + sc.Complete(); +} + +static const char * const asmWordListDesc[] = { + "CPU instructions", + "FPU instructions", + "Registers", + "Directives", + "Directive operands", + "Extended instructions", + 0 +}; + +LexerModule lmAsm(SCLEX_ASM, ColouriseAsmDoc, "asm", 0, asmWordListDesc); + diff --git a/sdk/wxscintilla/src/scintilla/src/LexAsn1.cxx b/sdk/wxscintilla/src/scintilla/src/LexAsn1.cxx new file mode 100644 index 0000000..28bf6d9 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexAsn1.cxx @@ -0,0 +1,185 @@ +// Scintilla source code edit control +/** @file LexAsn1.cxx + ** Lexer for ASN.1 + **/ +// Copyright 2004 by Herr Pfarrer rpfarrer yahoo de +// Last Updated: 20/07/2004 +// The License.txt file describes the conditions under which this software may be distributed. +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +// Some char test functions +static bool isAsn1Number(int ch) +{ + return (ch >= '0' && ch <= '9'); +} + +static bool isAsn1Letter(int ch) +{ + return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'); +} + +static bool isAsn1Char(int ch) +{ + return (ch == '-' ) || isAsn1Number(ch) || isAsn1Letter (ch); +} + +// +// Function determining the color of a given code portion +// Based on a "state" +// +static void ColouriseAsn1Doc(unsigned int startPos, int length, int initStyle, WordList *keywordLists[], Accessor &styler) +{ + // The keywords + WordList &Keywords = *keywordLists[0]; + WordList &Attributes = *keywordLists[1]; + WordList &Descriptors = *keywordLists[2]; + WordList &Types = *keywordLists[3]; + + // Parse the whole buffer character by character using StyleContext + StyleContext sc(startPos, length, initStyle, styler); + for (; sc.More(); sc.Forward()) + { + // The state engine + switch (sc.state) + { + case SCE_ASN1_DEFAULT: // Plain characters +asn1_default: + if (sc.ch == '-' && sc.chNext == '-') + // A comment begins here + sc.SetState(SCE_ASN1_COMMENT); + else if (sc.ch == '"') + // A string begins here + sc.SetState(SCE_ASN1_STRING); + else if (isAsn1Number (sc.ch)) + // A number starts here (identifier should start with a letter in ASN.1) + sc.SetState(SCE_ASN1_SCALAR); + else if (isAsn1Char (sc.ch)) + // An identifier starts here (identifier always start with a letter) + sc.SetState(SCE_ASN1_IDENTIFIER); + else if (sc.ch == ':') + // A ::= operator starts here + sc.SetState(SCE_ASN1_OPERATOR); + break; + case SCE_ASN1_COMMENT: // A comment + if (sc.ch == '\r' || sc.ch == '\n') + // A comment ends here + sc.SetState(SCE_ASN1_DEFAULT); + break; + case SCE_ASN1_IDENTIFIER: // An identifier (keyword, attribute, descriptor or type) + if (!isAsn1Char (sc.ch)) + { + // The end of identifier is here: we can look for it in lists by now and change its state + char s[100]; + sc.GetCurrent(s, sizeof(s)); + if (Keywords.InList(s)) + // It's a keyword, change its state + sc.ChangeState(SCE_ASN1_KEYWORD); + else if (Attributes.InList(s)) + // It's an attribute, change its state + sc.ChangeState(SCE_ASN1_ATTRIBUTE); + else if (Descriptors.InList(s)) + // It's a descriptor, change its state + sc.ChangeState(SCE_ASN1_DESCRIPTOR); + else if (Types.InList(s)) + // It's a type, change its state + sc.ChangeState(SCE_ASN1_TYPE); + + // Set to default now + sc.SetState(SCE_ASN1_DEFAULT); + } + break; + case SCE_ASN1_STRING: // A string delimited by "" + if (sc.ch == '"') + { + // A string ends here + sc.ForwardSetState(SCE_ASN1_DEFAULT); + + // To correctly manage a char sticking to the string quote + goto asn1_default; + } + break; + case SCE_ASN1_SCALAR: // A plain number + if (!isAsn1Number (sc.ch)) + // A number ends here + sc.SetState(SCE_ASN1_DEFAULT); + break; + case SCE_ASN1_OPERATOR: // The affectation operator ::= and wath follows (eg: ::= { org 6 } OID or ::= 12 trap) + if (sc.ch == '{') + { + // An OID definition starts here: enter the sub loop + for (; sc.More(); sc.Forward()) + { + if (isAsn1Number (sc.ch) && (!isAsn1Char (sc.chPrev) || isAsn1Number (sc.chPrev))) + // The OID number is highlighted + sc.SetState(SCE_ASN1_OID); + else if (isAsn1Char (sc.ch)) + // The OID parent identifier is plain + sc.SetState(SCE_ASN1_IDENTIFIER); + else + sc.SetState(SCE_ASN1_DEFAULT); + + if (sc.ch == '}') + // Here ends the OID and the operator sub loop: go back to main loop + break; + } + } + else if (isAsn1Number (sc.ch)) + { + // A trap number definition starts here: enter the sub loop + for (; sc.More(); sc.Forward()) + { + if (isAsn1Number (sc.ch)) + // The trap number is highlighted + sc.SetState(SCE_ASN1_OID); + else + { + // The number ends here: go back to main loop + sc.SetState(SCE_ASN1_DEFAULT); + break; + } + } + } + else if (sc.ch != ':' && sc.ch != '=' && sc.ch != ' ') + // The operator doesn't imply an OID definition nor a trap, back to main loop + goto asn1_default; // To be sure to handle actually the state change + break; + } + } + sc.Complete(); +} + +static void FoldAsn1Doc(unsigned int, int, int, WordList *[], Accessor &styler) +{ + // No folding enabled, no reason to continue... + if( styler.GetPropertyInt("fold") == 0 ) + return; + + // No folding implemented: doesn't make sense for ASN.1 +} + +static const char * const asn1WordLists[] = { + "Keywords", + "Attributes", + "Descriptors", + "Types", + 0, }; + + +LexerModule lmAns1(SCLEX_ASN1, ColouriseAsn1Doc, "asn1", FoldAsn1Doc, asn1WordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexBaan.cxx b/sdk/wxscintilla/src/scintilla/src/LexBaan.cxx new file mode 100644 index 0000000..97dd1f4 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexBaan.cxx @@ -0,0 +1,193 @@ +// Scintilla source code edit control +/** @file LexBaan.cxx + ** Lexer for Baan. + ** Based heavily on LexCPP.cxx + **/ +// Copyright 2001- by Vamsi Potluru & Praveen Ambekar +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '$' || ch == ':'); +} + +static inline bool IsAWordStart(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_'); +} + +static void ColouriseBaanDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + bool stylingWithinPreprocessor = styler.GetPropertyInt("styling.within.preprocessor") != 0; + + if (initStyle == SCE_BAAN_STRINGEOL) // Does not leak onto next line + initStyle = SCE_BAAN_DEFAULT; + + int visibleChars = 0; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + if (sc.state == SCE_BAAN_OPERATOR) { + sc.SetState(SCE_BAAN_DEFAULT); + } else if (sc.state == SCE_BAAN_NUMBER) { + if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_BAAN_DEFAULT); + } + } else if (sc.state == SCE_BAAN_IDENTIFIER) { + if (!IsAWordChar(sc.ch)) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + if (keywords.InList(s)) { + sc.ChangeState(SCE_BAAN_WORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_BAAN_WORD2); + } + sc.SetState(SCE_BAAN_DEFAULT); + } + } else if (sc.state == SCE_BAAN_PREPROCESSOR) { + if (stylingWithinPreprocessor) { + if (IsASpace(sc.ch)) { + sc.SetState(SCE_BAAN_DEFAULT); + } + } else { + if (sc.atLineEnd && (sc.chNext != '^')) { + sc.SetState(SCE_BAAN_DEFAULT); + } + } + } else if (sc.state == SCE_BAAN_COMMENT) { + if (sc.atLineEnd) { + sc.SetState(SCE_BAAN_DEFAULT); + } + } else if (sc.state == SCE_BAAN_COMMENTDOC) { + if (sc.MatchIgnoreCase("enddllusage")) { + for (unsigned int i = 0; i < 10; i++){ + sc.Forward(); + } + sc.ForwardSetState(SCE_BAAN_DEFAULT); + } + } else if (sc.state == SCE_BAAN_STRING) { + if (sc.ch == '\"') { + sc.ForwardSetState(SCE_BAAN_DEFAULT); + } else if ((sc.atLineEnd) && (sc.chNext != '^')) { + sc.ChangeState(SCE_BAAN_STRINGEOL); + sc.ForwardSetState(SCE_C_DEFAULT); + visibleChars = 0; + } + } + + if (sc.state == SCE_BAAN_DEFAULT) { + if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_BAAN_NUMBER); + } else if (sc.MatchIgnoreCase("dllusage")){ + sc.SetState(SCE_BAAN_COMMENTDOC); + do { + sc.Forward(); + } while ((!sc.atLineEnd) && sc.More()); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_BAAN_IDENTIFIER); + } else if (sc.Match('|')){ + sc.SetState(SCE_BAAN_COMMENT); + } else if (sc.ch == '\"') { + sc.SetState(SCE_BAAN_STRING); + } else if (sc.ch == '#' && visibleChars == 0) { + // Preprocessor commands are alone on their line + sc.SetState(SCE_BAAN_PREPROCESSOR); + // Skip whitespace between # and preprocessor word + do { + sc.Forward(); + } while (IsASpace(sc.ch) && sc.More()); + } else if (isoperator(static_cast(sc.ch))) { + sc.SetState(SCE_BAAN_OPERATOR); + } + } + if (sc.atLineEnd) { + // Reset states to begining of colourise so no surprises + // if different sets of lines lexed. + visibleChars = 0; + } + if (!IsASpace(sc.ch)) { + visibleChars++; + } + } + sc.Complete(); +} + +static void FoldBaanDoc(unsigned int startPos, int length, int initStyle, WordList *[], + Accessor &styler) { + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (foldComment && + (style == SCE_BAAN_COMMENT || style == SCE_BAAN_COMMENTDOC)) { + if (style != stylePrev) { + levelCurrent++; + } else if ((style != styleNext) && !atEOL) { + // Comments don't end at end of line and the next character may be unstyled. + levelCurrent--; + } + } + if (style == SCE_BAAN_OPERATOR) { + if (ch == '{') { + levelCurrent++; + } else if (ch == '}') { + levelCurrent--; + } + } + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) + visibleChars++; + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +LexerModule lmBaan(SCLEX_BAAN, ColouriseBaanDoc, "baan", FoldBaanDoc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexBash.cxx b/sdk/wxscintilla/src/scintilla/src/LexBash.cxx new file mode 100644 index 0000000..1f97e48 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexBash.cxx @@ -0,0 +1,521 @@ +// Scintilla source code edit control +/** @file LexBash.cxx + ** Lexer for Bash. + **/ +// Copyright 2004-2008 by Neil Hodgson +// Adapted from LexPerl by Kein-Hong Man 2004 +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "CharacterSet.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +#define HERE_DELIM_MAX 256 + +// define this if you want 'invalid octals' to be marked as errors +// usually, this is not a good idea, permissive lexing is better +#undef PEDANTIC_OCTAL + +#define BASH_BASE_ERROR 65 +#define BASH_BASE_DECIMAL 66 +#define BASH_BASE_HEX 67 +#ifdef PEDANTIC_OCTAL +#define BASH_BASE_OCTAL 68 +#define BASH_BASE_OCTAL_ERROR 69 +#endif + +static inline int translateBashDigit(int ch) { + if (ch >= '0' && ch <= '9') { + return ch - '0'; + } else if (ch >= 'a' && ch <= 'z') { + return ch - 'a' + 10; + } else if (ch >= 'A' && ch <= 'Z') { + return ch - 'A' + 36; + } else if (ch == '@') { + return 62; + } else if (ch == '_') { + return 63; + } + return BASH_BASE_ERROR; +} + +static inline int getBashNumberBase(char *s) { + int i = 0; + int base = 0; + while (*s) { + base = base * 10 + (*s++ - '0'); + i++; + } + if (base > 64 || i > 2) { + return BASH_BASE_ERROR; + } + return base; +} + +static int opposite(int ch) { + if (ch == '(') return ')'; + if (ch == '[') return ']'; + if (ch == '{') return '}'; + if (ch == '<') return '>'; + return ch; +} + +static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + + CharacterSet setWordStart(CharacterSet::setAlpha, "_"); + // note that [+-] are often parts of identifiers in shell scripts + CharacterSet setWord(CharacterSet::setAlphaNum, "._+-"); + CharacterSet setBashOperator(CharacterSet::setNone, "^&\\%()-+=|{}[]:;>,*/(ch); + Delimiter[DelimiterLength] = '\0'; + } + ~HereDocCls() { + delete []Delimiter; + } + }; + HereDocCls HereDoc; + + class QuoteCls { // Class to manage quote pairs (simplified vs LexPerl) + public: + int Count; + int Up, Down; + QuoteCls() { + Count = 0; + Up = '\0'; + Down = '\0'; + } + void Open(int u) { + Count++; + Up = u; + Down = opposite(Up); + } + void Start(int u) { + Count = 0; + Open(u); + } + }; + QuoteCls Quote; + + int numBase = 0; + int digit; + unsigned int endPos = startPos + length; + + // Backtrack to beginning of style if required... + // If in a long distance lexical state, backtrack to find quote characters + if (initStyle == SCE_SH_HERE_Q) { + while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_SH_HERE_DELIM)) { + startPos--; + } + startPos = styler.LineStart(styler.GetLine(startPos)); + initStyle = styler.StyleAt(startPos - 1); + } + // Bash strings can be multi-line with embedded newlines, so backtrack. + // Bash numbers have additional state during lexing, so backtrack too. + if (initStyle == SCE_SH_STRING + || initStyle == SCE_SH_BACKTICKS + || initStyle == SCE_SH_CHARACTER + || initStyle == SCE_SH_NUMBER + || initStyle == SCE_SH_IDENTIFIER + || initStyle == SCE_SH_COMMENTLINE) { + while ((startPos > 1) && (styler.StyleAt(startPos - 1) == initStyle)) { + startPos--; + } + initStyle = SCE_SH_DEFAULT; + } + + StyleContext sc(startPos, endPos - startPos, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_SH_OPERATOR: + sc.SetState(SCE_SH_DEFAULT); + break; + case SCE_SH_WORD: + // "." never used in Bash variable names but used in file names + if (!setWord.Contains(sc.ch)) { + char s[1000]; + sc.GetCurrent(s, sizeof(s)); + if (s[0] != '-' && // for file operators + !keywords.InList(s)) { + sc.ChangeState(SCE_SH_IDENTIFIER); + } + sc.SetState(SCE_SH_DEFAULT); + } + break; + case SCE_SH_IDENTIFIER: + if (sc.chPrev == '\\') { // for escaped chars + sc.ForwardSetState(SCE_SH_DEFAULT); + } else if (!setWord.Contains(sc.ch)) { + sc.SetState(SCE_SH_DEFAULT); + } + break; + case SCE_SH_NUMBER: + digit = translateBashDigit(sc.ch); + if (numBase == BASH_BASE_DECIMAL) { + if (sc.ch == '#') { + char s[10]; + sc.GetCurrent(s, sizeof(s)); + numBase = getBashNumberBase(s); + if (numBase != BASH_BASE_ERROR) + break; + } else if (IsADigit(sc.ch)) + break; + } else if (numBase == BASH_BASE_HEX) { + if (IsADigit(sc.ch, 16)) + break; +#ifdef PEDANTIC_OCTAL + } else if (numBase == BASH_BASE_OCTAL || + numBase == BASH_BASE_OCTAL_ERROR) { + if (digit <= 7) + break; + if (digit <= 9) { + numBase = BASH_BASE_OCTAL_ERROR; + break; + } +#endif + } else if (numBase == BASH_BASE_ERROR) { + if (digit <= 9) + break; + } else { // DD#DDDD number style handling + if (digit != BASH_BASE_ERROR) { + if (numBase <= 36) { + // case-insensitive if base<=36 + if (digit >= 36) digit -= 26; + } + if (digit < numBase) + break; + if (digit <= 9) { + numBase = BASH_BASE_ERROR; + break; + } + } + } + // fallthrough when number is at an end or error + if (numBase == BASH_BASE_ERROR +#ifdef PEDANTIC_OCTAL + || numBase == BASH_BASE_OCTAL_ERROR +#endif + ) { + sc.ChangeState(SCE_SH_ERROR); + } + sc.SetState(SCE_SH_DEFAULT); + break; + case SCE_SH_COMMENTLINE: + if (sc.atLineEnd && sc.chPrev != '\\') { + sc.SetState(SCE_SH_DEFAULT); + } + break; + case SCE_SH_HERE_DELIM: + // From Bash info: + // --------------- + // Specifier format is: <<[-]WORD + // Optional '-' is for removal of leading tabs from here-doc. + // Whitespace acceptable after <<[-] operator + // + if (HereDoc.State == 0) { // '<<' encountered + HereDoc.Quote = sc.chNext; + HereDoc.Quoted = false; + HereDoc.DelimiterLength = 0; + HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0'; + if (sc.chNext == '\'' || sc.chNext == '\"') { // a quoted here-doc delimiter (' or ") + sc.Forward(); + HereDoc.Quoted = true; + HereDoc.State = 1; + } else if (!HereDoc.Indent && sc.chNext == '-') { // <<- indent case + HereDoc.Indent = true; + } else if (setHereDoc.Contains(sc.chNext)) { + // an unquoted here-doc delimiter, no special handling + // TODO check what exactly bash considers part of the delim + HereDoc.State = 1; + } else if (sc.chNext == '<') { // HERE string <<< + sc.Forward(); + sc.ForwardSetState(SCE_SH_DEFAULT); + } else if (IsASpace(sc.chNext)) { + // eat whitespace + } else if (setLeftShift.Contains(sc.chNext)) { + // left shift << or <<= operator cases + sc.ChangeState(SCE_SH_OPERATOR); + sc.ForwardSetState(SCE_SH_DEFAULT); + } else { + // symbols terminates; deprecated zero-length delimiter + HereDoc.State = 1; + } + } else if (HereDoc.State == 1) { // collect the delimiter + if (setHereDoc2.Contains(sc.ch) || sc.chPrev == '\\') { + HereDoc.Append(sc.ch); + } else if (HereDoc.Quoted && sc.ch == HereDoc.Quote) { // closing quote => end of delimiter + sc.ForwardSetState(SCE_SH_DEFAULT); + } else if (sc.ch == '\\') { + // skip escape prefix + } else { + sc.SetState(SCE_SH_DEFAULT); + } + if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) { // force blowup + sc.SetState(SCE_SH_ERROR); + HereDoc.State = 0; + } + } + break; + case SCE_SH_HERE_Q: + // HereDoc.State == 2 + if (sc.atLineStart) { + sc.SetState(SCE_SH_HERE_Q); + int prefixws = 0; + while (IsASpace(sc.ch) && !sc.atLineEnd) { // whitespace prefix + sc.Forward(); + prefixws++; + } + if (prefixws > 0) + sc.SetState(SCE_SH_HERE_Q); + while (!sc.atLineEnd) { + sc.Forward(); + } + char s[HERE_DELIM_MAX]; + sc.GetCurrent(s, sizeof(s)); + if (sc.LengthCurrent() == 0) + break; + if (s[strlen(s) - 1] == '\r') + s[strlen(s) - 1] = '\0'; + if (strcmp(HereDoc.Delimiter, s) == 0) { + if ((prefixws > 0 && HereDoc.Indent) || // indentation rule + (prefixws == 0 && !HereDoc.Indent)) { + sc.SetState(SCE_SH_DEFAULT); + break; + } + } + } + break; + case SCE_SH_SCALAR: // variable names + if (!setParam.Contains(sc.ch)) { + if (sc.LengthCurrent() == 1) { + // Special variable: $(, $_ etc. + sc.ForwardSetState(SCE_SH_DEFAULT); + } else { + sc.SetState(SCE_SH_DEFAULT); + } + } + break; + case SCE_SH_STRING: // delimited styles + case SCE_SH_CHARACTER: + case SCE_SH_BACKTICKS: + case SCE_SH_PARAM: + if (sc.ch == '\\' && Quote.Up != '\\') { + sc.Forward(); + } else if (sc.ch == Quote.Down) { + Quote.Count--; + if (Quote.Count == 0) { + sc.ForwardSetState(SCE_SH_DEFAULT); + } + } else if (sc.ch == Quote.Up) { + Quote.Count++; + } + break; + } + + // Must check end of HereDoc state 1 before default state is handled + if (HereDoc.State == 1 && sc.atLineEnd) { + // Begin of here-doc (the line after the here-doc delimiter): + // Lexically, the here-doc starts from the next line after the >>, but the + // first line of here-doc seem to follow the style of the last EOL sequence + HereDoc.State = 2; + if (HereDoc.Quoted) { + if (sc.state == SCE_SH_HERE_DELIM) { + // Missing quote at end of string! We are stricter than bash. + // Colour here-doc anyway while marking this bit as an error. + sc.ChangeState(SCE_SH_ERROR); + } + // HereDoc.Quote always == '\'' + } + sc.SetState(SCE_SH_HERE_Q); + } + + // Determine if a new state should be entered. + if (sc.state == SCE_SH_DEFAULT) { + if (sc.ch == '\\') { // escaped character + sc.SetState(SCE_SH_IDENTIFIER); + } else if (IsADigit(sc.ch)) { + sc.SetState(SCE_SH_NUMBER); + numBase = BASH_BASE_DECIMAL; + if (sc.ch == '0') { // hex,octal + if (sc.chNext == 'x' || sc.chNext == 'X') { + numBase = BASH_BASE_HEX; + sc.Forward(); + } else if (IsADigit(sc.chNext)) { +#ifdef PEDANTIC_OCTAL + numBase = BASH_BASE_OCTAL; +#else + numBase = BASH_BASE_HEX; +#endif + } + } + } else if (setWordStart.Contains(sc.ch)) { + sc.SetState(SCE_SH_WORD); + } else if (sc.ch == '#') { + sc.SetState(SCE_SH_COMMENTLINE); + } else if (sc.ch == '\"') { + sc.SetState(SCE_SH_STRING); + Quote.Start(sc.ch); + } else if (sc.ch == '\'') { + sc.SetState(SCE_SH_CHARACTER); + Quote.Start(sc.ch); + } else if (sc.ch == '`') { + sc.SetState(SCE_SH_BACKTICKS); + Quote.Start(sc.ch); + } else if (sc.ch == '$') { + sc.SetState(SCE_SH_SCALAR); + sc.Forward(); + if (sc.ch == '{') { + sc.ChangeState(SCE_SH_PARAM); + } else if (sc.ch == '\'') { + sc.ChangeState(SCE_SH_CHARACTER); + } else if (sc.ch == '"') { + sc.ChangeState(SCE_SH_STRING); + } else if (sc.ch == '(' || sc.ch == '`') { + sc.ChangeState(SCE_SH_BACKTICKS); + if (sc.chNext == '(') { // $(( is lexed as operator + sc.ChangeState(SCE_SH_OPERATOR); + } + } else { + continue; // scalar has no delimiter pair + } + // fallthrough, open delim for $[{'"(`] + Quote.Start(sc.ch); + } else if (sc.Match('<', '<')) { + sc.SetState(SCE_SH_HERE_DELIM); + HereDoc.State = 0; + HereDoc.Indent = false; + } else if (sc.ch == '-' && // one-char file test operators + setSingleCharOp.Contains(sc.chNext) && + !setWord.Contains(sc.GetRelative(2)) && + IsASpace(sc.chPrev)) { + sc.SetState(SCE_SH_WORD); + sc.Forward(); + } else if (setBashOperator.Contains(sc.ch)) { + sc.SetState(SCE_SH_OPERATOR); + } + } + } + sc.Complete(); +} + +static bool IsCommentLine(int line, Accessor &styler) { + int pos = styler.LineStart(line); + int eol_pos = styler.LineStart(line + 1) - 1; + for (int i = pos; i < eol_pos; i++) { + char ch = styler[i]; + if (ch == '#') + return true; + else if (ch != ' ' && ch != '\t') + return false; + } + return false; +} + +static void FoldBashDoc(unsigned int startPos, int length, int, WordList *[], + Accessor &styler) { + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + // Comment folding + if (foldComment && atEOL && IsCommentLine(lineCurrent, styler)) + { + if (!IsCommentLine(lineCurrent - 1, styler) + && IsCommentLine(lineCurrent + 1, styler)) + levelCurrent++; + else if (IsCommentLine(lineCurrent - 1, styler) + && !IsCommentLine(lineCurrent + 1, styler)) + levelCurrent--; + } + if (style == SCE_SH_OPERATOR) { + if (ch == '{') { + levelCurrent++; + } else if (ch == '}') { + levelCurrent--; + } + } + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) + visibleChars++; + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +static const char * const bashWordListDesc[] = { + "Keywords", + 0 +}; + +LexerModule lmBash(SCLEX_BASH, ColouriseBashDoc, "bash", FoldBashDoc, bashWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexBasic.cxx b/sdk/wxscintilla/src/scintilla/src/LexBasic.cxx new file mode 100644 index 0000000..9a52186 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexBasic.cxx @@ -0,0 +1,373 @@ +// Scintilla source code edit control +/** @file LexBasic.cxx + ** Lexer for BlitzBasic and PureBasic. + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +// This tries to be a unified Lexer/Folder for all the BlitzBasic/BlitzMax/PurBasic basics +// and derivatives. Once they diverge enough, might want to split it into multiple +// lexers for more code clearity. +// +// Mail me (elias users sf net) for any bugs. + +// Folding only works for simple things like functions or types. + +// You may want to have a look at my ctags lexer as well, if you additionally to coloring +// and folding need to extract things like label tags in your editor. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +/* Bits: + * 1 - whitespace + * 2 - operator + * 4 - identifier + * 8 - decimal digit + * 16 - hex digit + * 32 - bin digit + */ +static int character_classification[128] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10, 2, + 60, 60, 28, 28, 28, 28, 28, 28, 28, 28, 2, 2, 2, 2, 2, 2, + 2, 20, 20, 20, 20, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 4, + 2, 20, 20, 20, 20, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0 +}; + +static bool IsSpace(int c) { + return c < 128 && (character_classification[c] & 1); +} + +static bool IsOperator(int c) { + return c < 128 && (character_classification[c] & 2); +} + +static bool IsIdentifier(int c) { + return c < 128 && (character_classification[c] & 4); +} + +static bool IsDigit(int c) { + return c < 128 && (character_classification[c] & 8); +} + +static bool IsHexDigit(int c) { + return c < 128 && (character_classification[c] & 16); +} + +static bool IsBinDigit(int c) { + return c < 128 && (character_classification[c] & 32); +} + +static int LowerCase(int c) +{ + if (c >= 'A' && c <= 'Z') + return 'a' + c - 'A'; + return c; +} + +static void ColouriseBasicDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler, char comment_char) { + bool wasfirst = true, isfirst = true; // true if first token in a line + styler.StartAt(startPos); + + StyleContext sc(startPos, length, initStyle, styler); + + // Can't use sc.More() here else we miss the last character + for (; ; sc.Forward()) { + if (sc.state == SCE_B_IDENTIFIER) { + if (!IsIdentifier(sc.ch)) { + // Labels + if (wasfirst && sc.Match(':')) { + sc.ChangeState(SCE_B_LABEL); + sc.ForwardSetState(SCE_B_DEFAULT); + } else { + char s[100]; + int kstates[4] = { + SCE_B_KEYWORD, + SCE_B_KEYWORD2, + SCE_B_KEYWORD3, + SCE_B_KEYWORD4, + }; + sc.GetCurrentLowered(s, sizeof(s)); + for (int i = 0; i < 4; i++) { + if (keywordlists[i]->InList(s)) { + sc.ChangeState(kstates[i]); + } + } + // Types, must set them as operator else they will be + // matched as number/constant + if (sc.Match('.') || sc.Match('$') || sc.Match('%') || + sc.Match('#')) { + sc.SetState(SCE_B_OPERATOR); + } else { + sc.SetState(SCE_B_DEFAULT); + } + } + } + } else if (sc.state == SCE_B_OPERATOR) { + if (!IsOperator(sc.ch) || sc.Match('#')) + sc.SetState(SCE_B_DEFAULT); + } else if (sc.state == SCE_B_LABEL) { + if (!IsIdentifier(sc.ch)) + sc.SetState(SCE_B_DEFAULT); + } else if (sc.state == SCE_B_CONSTANT) { + if (!IsIdentifier(sc.ch)) + sc.SetState(SCE_B_DEFAULT); + } else if (sc.state == SCE_B_NUMBER) { + if (!IsDigit(sc.ch)) + sc.SetState(SCE_B_DEFAULT); + } else if (sc.state == SCE_B_HEXNUMBER) { + if (!IsHexDigit(sc.ch)) + sc.SetState(SCE_B_DEFAULT); + } else if (sc.state == SCE_B_BINNUMBER) { + if (!IsBinDigit(sc.ch)) + sc.SetState(SCE_B_DEFAULT); + } else if (sc.state == SCE_B_STRING) { + if (sc.ch == '"') { + sc.ForwardSetState(SCE_B_DEFAULT); + } + if (sc.atLineEnd) { + sc.ChangeState(SCE_B_ERROR); + sc.SetState(SCE_B_DEFAULT); + } + } else if (sc.state == SCE_B_COMMENT || sc.state == SCE_B_PREPROCESSOR) { + if (sc.atLineEnd) { + sc.SetState(SCE_B_DEFAULT); + } + } + + if (sc.atLineStart) + isfirst = true; + + if (sc.state == SCE_B_DEFAULT || sc.state == SCE_B_ERROR) { + if (isfirst && sc.Match('.')) { + sc.SetState(SCE_B_LABEL); + } else if (isfirst && sc.Match('#')) { + wasfirst = isfirst; + sc.SetState(SCE_B_IDENTIFIER); + } else if (sc.Match(comment_char)) { + // Hack to make deprecated QBASIC '$Include show + // up in freebasic with SCE_B_PREPROCESSOR. + if (comment_char == '\'' && sc.Match(comment_char, '$')) + sc.SetState(SCE_B_PREPROCESSOR); + else + sc.SetState(SCE_B_COMMENT); + } else if (sc.Match('"')) { + sc.SetState(SCE_B_STRING); + } else if (IsDigit(sc.ch)) { + sc.SetState(SCE_B_NUMBER); + } else if (sc.Match('$')) { + sc.SetState(SCE_B_HEXNUMBER); + } else if (sc.Match('%')) { + sc.SetState(SCE_B_BINNUMBER); + } else if (sc.Match('#')) { + sc.SetState(SCE_B_CONSTANT); + } else if (IsOperator(sc.ch)) { + sc.SetState(SCE_B_OPERATOR); + } else if (IsIdentifier(sc.ch)) { + wasfirst = isfirst; + sc.SetState(SCE_B_IDENTIFIER); + } else if (!IsSpace(sc.ch)) { + sc.SetState(SCE_B_ERROR); + } + } + + if (!IsSpace(sc.ch)) + isfirst = false; + + if (!sc.More()) + break; + } + sc.Complete(); +} + +static int CheckBlitzFoldPoint(char const *token, int &level) { + if (!strcmp(token, "function") || + !strcmp(token, "type")) { + level |= SC_FOLDLEVELHEADERFLAG; + return 1; + } + if (!strcmp(token, "end function") || + !strcmp(token, "end type")) { + return -1; + } + return 0; +} + +static int CheckPureFoldPoint(char const *token, int &level) { + if (!strcmp(token, "procedure") || + !strcmp(token, "enumeration") || + !strcmp(token, "interface") || + !strcmp(token, "structure")) { + level |= SC_FOLDLEVELHEADERFLAG; + return 1; + } + if (!strcmp(token, "endprocedure") || + !strcmp(token, "endenumeration") || + !strcmp(token, "endinterface") || + !strcmp(token, "endstructure")) { + return -1; + } + return 0; +} + +static int CheckFreeFoldPoint(char const *token, int &level) { + if (!strcmp(token, "function") || + !strcmp(token, "sub") || + !strcmp(token, "type")) { + level |= SC_FOLDLEVELHEADERFLAG; + return 1; + } + if (!strcmp(token, "end function") || + !strcmp(token, "end sub") || + !strcmp(token, "end type")) { + return -1; + } + return 0; +} + +static void FoldBasicDoc(unsigned int startPos, int length, + Accessor &styler, int (*CheckFoldPoint)(char const *, int &)) { + int line = styler.GetLine(startPos); + int level = styler.LevelAt(line); + int go = 0, done = 0; + int endPos = startPos + length; + char word[256]; + int wordlen = 0; + int i; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + // Scan for tokens at the start of the line (they may include + // whitespace, for tokens like "End Function" + for (i = startPos; i < endPos; i++) { + int c = styler.SafeGetCharAt(i); + if (!done && !go) { + if (wordlen) { // are we scanning a token already? + word[wordlen] = static_cast(LowerCase(c)); + if (!IsIdentifier(c)) { // done with token + word[wordlen] = '\0'; + go = CheckFoldPoint(word, level); + if (!go) { + // Treat any whitespace as single blank, for + // things like "End Function". + if (IsSpace(c) && IsIdentifier(word[wordlen - 1])) { + word[wordlen] = ' '; + if (wordlen < 255) + wordlen++; + } + else // done with this line + done = 1; + } + } else if (wordlen < 255) { + wordlen++; + } + } else { // start scanning at first non-whitespace character + if (!IsSpace(c)) { + if (IsIdentifier(c)) { + word[0] = static_cast(LowerCase(c)); + wordlen = 1; + } else // done with this line + done = 1; + } + } + } + if (c == '\n') { // line end + if (!done && wordlen == 0 && foldCompact) // line was only space + level |= SC_FOLDLEVELWHITEFLAG; + if (level != styler.LevelAt(line)) + styler.SetLevel(line, level); + level += go; + line++; + // reset state + wordlen = 0; + level &= ~SC_FOLDLEVELHEADERFLAG; + level &= ~SC_FOLDLEVELWHITEFLAG; + go = 0; + done = 0; + } + } +} + +static void ColouriseBlitzBasicDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) { + ColouriseBasicDoc(startPos, length, initStyle, keywordlists, styler, ';'); +} + +static void ColourisePureBasicDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) { + ColouriseBasicDoc(startPos, length, initStyle, keywordlists, styler, ';'); +} + +static void ColouriseFreeBasicDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) { + ColouriseBasicDoc(startPos, length, initStyle, keywordlists, styler, '\''); +} + +static void FoldBlitzBasicDoc(unsigned int startPos, int length, int, + WordList *[], Accessor &styler) { + FoldBasicDoc(startPos, length, styler, CheckBlitzFoldPoint); +} + +static void FoldPureBasicDoc(unsigned int startPos, int length, int, + WordList *[], Accessor &styler) { + FoldBasicDoc(startPos, length, styler, CheckPureFoldPoint); +} + +static void FoldFreeBasicDoc(unsigned int startPos, int length, int, + WordList *[], Accessor &styler) { + FoldBasicDoc(startPos, length, styler, CheckFreeFoldPoint); +} + +static const char * const blitzbasicWordListDesc[] = { + "BlitzBasic Keywords", + "user1", + "user2", + "user3", + 0 +}; + +static const char * const purebasicWordListDesc[] = { + "PureBasic Keywords", + "PureBasic PreProcessor Keywords", + "user defined 1", + "user defined 2", + 0 +}; + +static const char * const freebasicWordListDesc[] = { + "FreeBasic Keywords", + "FreeBasic PreProcessor Keywords", + "user defined 1", + "user defined 2", + 0 +}; + +LexerModule lmBlitzBasic(SCLEX_BLITZBASIC, ColouriseBlitzBasicDoc, "blitzbasic", + FoldBlitzBasicDoc, blitzbasicWordListDesc); + +LexerModule lmPureBasic(SCLEX_PUREBASIC, ColourisePureBasicDoc, "purebasic", + FoldPureBasicDoc, purebasicWordListDesc); + +LexerModule lmFreeBasic(SCLEX_FREEBASIC, ColouriseFreeBasicDoc, "freebasic", + FoldFreeBasicDoc, freebasicWordListDesc); + diff --git a/sdk/wxscintilla/src/scintilla/src/LexBullant.cxx b/sdk/wxscintilla/src/scintilla/src/LexBullant.cxx new file mode 100644 index 0000000..28e2e75 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexBullant.cxx @@ -0,0 +1,229 @@ +// SciTE - Scintilla based Text Editor +// LexBullant.cxx - lexer for Bullant + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static int classifyWordBullant(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) { + char s[100]; + s[0] = '\0'; + for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) { + s[i] = static_cast(tolower(styler[start + i])); + s[i + 1] = '\0'; + } + int lev= 0; + char chAttr = SCE_C_IDENTIFIER; + if (isdigit(s[0]) || (s[0] == '.')){ + chAttr = SCE_C_NUMBER; + } + else { + if (keywords.InList(s)) { + chAttr = SCE_C_WORD; + if (strcmp(s, "end") == 0) + lev = -1; + else if (strcmp(s, "method") == 0 || + strcmp(s, "case") == 0 || + strcmp(s, "class") == 0 || + strcmp(s, "debug") == 0 || + strcmp(s, "test") == 0 || + strcmp(s, "if") == 0 || + strcmp(s, "lock") == 0 || + strcmp(s, "transaction") == 0 || + strcmp(s, "trap") == 0 || + strcmp(s, "until") == 0 || + strcmp(s, "while") == 0) + lev = 1; + } + } + styler.ColourTo(end, chAttr); + return lev; +} + +static void ColouriseBullantDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + WordList &keywords = *keywordlists[0]; + + styler.StartAt(startPos); + + bool fold = styler.GetPropertyInt("fold") != 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + + int state = initStyle; + if (state == SCE_C_STRINGEOL) // Does not leak onto next line + state = SCE_C_DEFAULT; + char chPrev = ' '; + char chNext = styler[startPos]; + unsigned int lengthDoc = startPos + length; + int visibleChars = 0; + styler.StartSegment(startPos); + int endFoundThisLine = 0; + for (unsigned int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + if ((ch == '\r' && chNext != '\n') || (ch == '\n')) { + // Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix) + // Avoid triggering two times on Dos/Win + // End of line + endFoundThisLine = 0; + if (state == SCE_C_STRINGEOL) { + styler.ColourTo(i, state); + state = SCE_C_DEFAULT; + } + if (fold) { + int lev = levelPrev; + if (visibleChars == 0) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + styler.SetLevel(lineCurrent, lev); + lineCurrent++; + levelPrev = levelCurrent; + } + visibleChars = 0; + +/* int indentBlock = GetLineIndentation(lineCurrent); + if (blockChange==1){ + lineCurrent++; + int pos=SetLineIndentation(lineCurrent, indentBlock + indentSize); + } else if (blockChange==-1) { + indentBlock -= indentSize; + if (indentBlock < 0) + indentBlock = 0; + SetLineIndentation(lineCurrent, indentBlock); + lineCurrent++; + } + blockChange=0; +*/ } + if (!(isascii(ch) && isspace(ch))) + visibleChars++; + + if (styler.IsLeadByte(ch)) { + chNext = styler.SafeGetCharAt(i + 2); + chPrev = ' '; + i += 1; + continue; + } + + if (state == SCE_C_DEFAULT) { + if (iswordstart(ch)) { + styler.ColourTo(i-1, state); + state = SCE_C_IDENTIFIER; + } else if (ch == '@' && chNext == 'o') { + if ((styler.SafeGetCharAt(i+2) =='f') && (styler.SafeGetCharAt(i+3) == 'f')) { + styler.ColourTo(i-1, state); + state = SCE_C_COMMENT; + } + } else if (ch == '#') { + styler.ColourTo(i-1, state); + state = SCE_C_COMMENTLINE; + } else if (ch == '\"') { + styler.ColourTo(i-1, state); + state = SCE_C_STRING; + } else if (ch == '\'') { + styler.ColourTo(i-1, state); + state = SCE_C_CHARACTER; + } else if (isoperator(ch)) { + styler.ColourTo(i-1, state); + styler.ColourTo(i, SCE_C_OPERATOR); + } + } else if (state == SCE_C_IDENTIFIER) { + if (!iswordchar(ch)) { + int levelChange = classifyWordBullant(styler.GetStartSegment(), i - 1, keywords, styler); + state = SCE_C_DEFAULT; + chNext = styler.SafeGetCharAt(i + 1); + if (ch == '#') { + state = SCE_C_COMMENTLINE; + } else if (ch == '\"') { + state = SCE_C_STRING; + } else if (ch == '\'') { + state = SCE_C_CHARACTER; + } else if (isoperator(ch)) { + styler.ColourTo(i, SCE_C_OPERATOR); + } + if (endFoundThisLine == 0) + levelCurrent+=levelChange; + if (levelChange == -1) + endFoundThisLine=1; + } + } else if (state == SCE_C_COMMENT) { + if (ch == '@' && chNext == 'o') { + if (styler.SafeGetCharAt(i+2) == 'n') { + styler.ColourTo(i+2, state); + state = SCE_C_DEFAULT; + i+=2; + } + } + } else if (state == SCE_C_COMMENTLINE) { + if (ch == '\r' || ch == '\n') { + endFoundThisLine = 0; + styler.ColourTo(i-1, state); + state = SCE_C_DEFAULT; + } + } else if (state == SCE_C_STRING) { + if (ch == '\\') { + if (chNext == '\"' || chNext == '\'' || chNext == '\\') { + i++; + ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + } + } else if (ch == '\"') { + styler.ColourTo(i, state); + state = SCE_C_DEFAULT; + } else if (chNext == '\r' || chNext == '\n') { + endFoundThisLine = 0; + styler.ColourTo(i-1, SCE_C_STRINGEOL); + state = SCE_C_STRINGEOL; + } + } else if (state == SCE_C_CHARACTER) { + if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) { + endFoundThisLine = 0; + styler.ColourTo(i-1, SCE_C_STRINGEOL); + state = SCE_C_STRINGEOL; + } else if (ch == '\\') { + if (chNext == '\"' || chNext == '\'' || chNext == '\\') { + i++; + ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + } + } else if (ch == '\'') { + styler.ColourTo(i, state); + state = SCE_C_DEFAULT; + } + } + chPrev = ch; + } + styler.ColourTo(lengthDoc - 1, state); + + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + if (fold) { + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + //styler.SetLevel(lineCurrent, levelCurrent | flagsNext); + styler.SetLevel(lineCurrent, levelPrev | flagsNext); + + } +} + +static const char * const bullantWordListDesc[] = { + "Keywords", + 0 +}; + +LexerModule lmBullant(SCLEX_BULLANT, ColouriseBullantDoc, "bullant", 0, bullantWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCLW.cxx b/sdk/wxscintilla/src/scintilla/src/LexCLW.cxx new file mode 100644 index 0000000..3416bf2 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCLW.cxx @@ -0,0 +1,679 @@ +// Scintilla source code edit control +/** @file LexClw.cxx + ** Lexer for Clarion. + ** 2004/12/17 Updated Lexer + **/ +// Copyright 2003-2004 by Ron Schofield +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +// Is an end of line character +inline bool IsEOL(const int ch) { + + return(ch == '\n'); +} + +// Convert character to uppercase +static char CharacterUpper(char chChar) { + + if (chChar < 'a' || chChar > 'z') { + return(chChar); + } + else { + return(static_cast(chChar - 'a' + 'A')); + } +} + +// Convert string to uppercase +static void StringUpper(char *szString) { + + while (*szString) { + *szString = CharacterUpper(*szString); + szString++; + } +} + +// Is a label start character +inline bool IsALabelStart(const int iChar) { + + return(isalpha(iChar) || iChar == '_'); +} + +// Is a label character +inline bool IsALabelCharacter(const int iChar) { + + return(isalnum(iChar) || iChar == '_' || iChar == ':'); +} + +// Is the character is a ! and the the next character is not a ! +inline bool IsACommentStart(const int iChar) { + + return(iChar == '!'); +} + +// Is the character a Clarion hex character (ABCDEF) +inline bool IsAHexCharacter(const int iChar, bool bCaseSensitive) { + + // Case insensitive. + if (!bCaseSensitive) { + if (strchr("ABCDEFabcdef", iChar) != NULL) { + return(true); + } + } + // Case sensitive + else { + if (strchr("ABCDEF", iChar) != NULL) { + return(true); + } + } + return(false); +} + +// Is the character a Clarion base character (B=Binary, O=Octal, H=Hex) +inline bool IsANumericBaseCharacter(const int iChar, bool bCaseSensitive) { + + // Case insensitive. + if (!bCaseSensitive) { + // If character is a numeric base character + if (strchr("BOHboh", iChar) != NULL) { + return(true); + } + } + // Case sensitive + else { + // If character is a numeric base character + if (strchr("BOH", iChar) != NULL) { + return(true); + } + } + return(false); +} + +// Set the correct numeric constant state +inline bool SetNumericConstantState(StyleContext &scDoc) { + + int iPoints = 0; // Point counter + char cNumericString[512]; // Numeric string buffer + + // Buffer the current numberic string + scDoc.GetCurrent(cNumericString, sizeof(cNumericString)); + // Loop through the string until end of string (NULL termination) + for (int iIndex = 0; cNumericString[iIndex] != '\0'; iIndex++) { + // Depending on the character + switch (cNumericString[iIndex]) { + // Is a . (point) + case '.' : + // Increment point counter + iPoints++; + break; + default : + break; + } + } + // If points found (can be more than one for improper formatted number + if (iPoints > 0) { + return(true); + } + // Else no points found + else { + return(false); + } +} + +// Get the next word in uppercase from the current position (keyword lookahead) +inline bool GetNextWordUpper(Accessor &styler, unsigned int uiStartPos, int iLength, char *cWord) { + + unsigned int iIndex = 0; // Buffer Index + + // Loop through the remaining string from the current position + for (int iOffset = uiStartPos; iOffset < iLength; iOffset++) { + // Get the character from the buffer using the offset + char cCharacter = styler[iOffset]; + if (IsEOL(cCharacter)) { + break; + } + // If the character is alphabet character + if (isalpha(cCharacter)) { + // Add UPPERCASE character to the word buffer + cWord[iIndex++] = CharacterUpper(cCharacter); + } + } + // Add null termination + cWord[iIndex] = '\0'; + // If no word was found + if (iIndex == 0) { + // Return failure + return(false); + } + // Else word was found + else { + // Return success + return(true); + } +} + +// Clarion Language Colouring Procedure +static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler, bool bCaseSensitive) { + + int iParenthesesLevel = 0; // Parenthese Level + int iColumn1Label = false; // Label starts in Column 1 + + WordList &wlClarionKeywords = *wlKeywords[0]; // Clarion Keywords + WordList &wlCompilerDirectives = *wlKeywords[1]; // Compiler Directives + WordList &wlRuntimeExpressions = *wlKeywords[2]; // Runtime Expressions + WordList &wlBuiltInProcsFuncs = *wlKeywords[3]; // Builtin Procedures and Functions + WordList &wlStructsDataTypes = *wlKeywords[4]; // Structures and Data Types + WordList &wlAttributes = *wlKeywords[5]; // Procedure Attributes + WordList &wlStandardEquates = *wlKeywords[6]; // Standard Equates + WordList &wlLabelReservedWords = *wlKeywords[7]; // Clarion Reserved Keywords (Labels) + WordList &wlProcLabelReservedWords = *wlKeywords[8]; // Clarion Reserved Keywords (Procedure Labels) + + const char wlProcReservedKeywordList[] = + "PROCEDURE FUNCTION"; + WordList wlProcReservedKeywords; + wlProcReservedKeywords.Set(wlProcReservedKeywordList); + + const char wlCompilerKeywordList[] = + "COMPILE OMIT"; + WordList wlCompilerKeywords; + wlCompilerKeywords.Set(wlCompilerKeywordList); + + const char wlLegacyStatementsList[] = + "BOF EOF FUNCTION POINTER SHARE"; + WordList wlLegacyStatements; + wlLegacyStatements.Set(wlLegacyStatementsList); + + StyleContext scDoc(uiStartPos, iLength, iInitStyle, accStyler); + + // lex source code + for (; scDoc.More(); scDoc.Forward()) + { + // + // Determine if the current state should terminate. + // + + // Label State Handling + if (scDoc.state == SCE_CLW_LABEL) { + // If the character is not a valid label + if (!IsALabelCharacter(scDoc.ch)) { + // If the character is a . (dot syntax) + if (scDoc.ch == '.') { + // Turn off column 1 label flag as label now cannot be reserved work + iColumn1Label = false; + // Uncolour the . (dot) to default state, move forward one character, + // and change back to the label state. + scDoc.SetState(SCE_CLW_DEFAULT); + scDoc.Forward(); + scDoc.SetState(SCE_CLW_LABEL); + } + // Else check label + else { + char cLabel[512]; // Label buffer + // Buffer the current label string + scDoc.GetCurrent(cLabel,sizeof(cLabel)); + // If case insensitive, convert string to UPPERCASE to match passed keywords. + if (!bCaseSensitive) { + StringUpper(cLabel); + } + // Else if UPPERCASE label string is in the Clarion compiler keyword list + if (wlCompilerKeywords.InList(cLabel) && iColumn1Label){ + // change the label to error state + scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE); + } + // Else if UPPERCASE label string is in the Clarion reserved keyword list + else if (wlLabelReservedWords.InList(cLabel) && iColumn1Label){ + // change the label to error state + scDoc.ChangeState(SCE_CLW_ERROR); + } + // Else if UPPERCASE label string is + else if (wlProcLabelReservedWords.InList(cLabel) && iColumn1Label) { + char cWord[512]; // Word buffer + // Get the next word from the current position + if (GetNextWordUpper(accStyler,scDoc.currentPos,uiStartPos+iLength,cWord)) { + // If the next word is a procedure reserved word + if (wlProcReservedKeywords.InList(cWord)) { + // Change the label to error state + scDoc.ChangeState(SCE_CLW_ERROR); + } + } + } + // Else if label string is in the compiler directive keyword list + else if (wlCompilerDirectives.InList(cLabel)) { + // change the state to compiler directive state + scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE); + } + // Terminate the label state and set to default state + scDoc.SetState(SCE_CLW_DEFAULT); + } + } + } + // Keyword State Handling + else if (scDoc.state == SCE_CLW_KEYWORD) { + // If character is : (colon) + if (scDoc.ch == ':') { + char cEquate[512]; // Equate buffer + // Move forward to include : (colon) in buffer + scDoc.Forward(); + // Buffer the equate string + scDoc.GetCurrent(cEquate,sizeof(cEquate)); + // If case insensitive, convert string to UPPERCASE to match passed keywords. + if (!bCaseSensitive) { + StringUpper(cEquate); + } + // If statement string is in the equate list + if (wlStandardEquates.InList(cEquate)) { + // Change to equate state + scDoc.ChangeState(SCE_CLW_STANDARD_EQUATE); + } + } + // If the character is not a valid label character + else if (!IsALabelCharacter(scDoc.ch)) { + char cStatement[512]; // Statement buffer + // Buffer the statement string + scDoc.GetCurrent(cStatement,sizeof(cStatement)); + // If case insensitive, convert string to UPPERCASE to match passed keywords. + if (!bCaseSensitive) { + StringUpper(cStatement); + } + // If statement string is in the Clarion keyword list + if (wlClarionKeywords.InList(cStatement)) { + // Change the statement string to the Clarion keyword state + scDoc.ChangeState(SCE_CLW_KEYWORD); + } + // Else if statement string is in the compiler directive keyword list + else if (wlCompilerDirectives.InList(cStatement)) { + // Change the statement string to the compiler directive state + scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE); + } + // Else if statement string is in the runtime expressions keyword list + else if (wlRuntimeExpressions.InList(cStatement)) { + // Change the statement string to the runtime expressions state + scDoc.ChangeState(SCE_CLW_RUNTIME_EXPRESSIONS); + } + // Else if statement string is in the builtin procedures and functions keyword list + else if (wlBuiltInProcsFuncs.InList(cStatement)) { + // Change the statement string to the builtin procedures and functions state + scDoc.ChangeState(SCE_CLW_BUILTIN_PROCEDURES_FUNCTION); + } + // Else if statement string is in the tructures and data types keyword list + else if (wlStructsDataTypes.InList(cStatement)) { + // Change the statement string to the structures and data types state + scDoc.ChangeState(SCE_CLW_STRUCTURE_DATA_TYPE); + } + // Else if statement string is in the procedure attribute keyword list + else if (wlAttributes.InList(cStatement)) { + // Change the statement string to the procedure attribute state + scDoc.ChangeState(SCE_CLW_ATTRIBUTE); + } + // Else if statement string is in the standard equate keyword list + else if (wlStandardEquates.InList(cStatement)) { + // Change the statement string to the standard equate state + scDoc.ChangeState(SCE_CLW_STANDARD_EQUATE); + } + // Else if statement string is in the deprecated or legacy keyword list + else if (wlLegacyStatements.InList(cStatement)) { + // Change the statement string to the standard equate state + scDoc.ChangeState(SCE_CLW_DEPRECATED); + } + // Else the statement string doesn't match any work list + else { + // Change the statement string to the default state + scDoc.ChangeState(SCE_CLW_DEFAULT); + } + // Terminate the keyword state and set to default state + scDoc.SetState(SCE_CLW_DEFAULT); + } + } + // String State Handling + else if (scDoc.state == SCE_CLW_STRING) { + // If the character is an ' (single quote) + if (scDoc.ch == '\'') { + // Set the state to default and move forward colouring + // the ' (single quote) as default state + // terminating the string state + scDoc.SetState(SCE_CLW_DEFAULT); + scDoc.Forward(); + } + // If the next character is an ' (single quote) + if (scDoc.chNext == '\'') { + // Move forward one character and set to default state + // colouring the next ' (single quote) as default state + // terminating the string state + scDoc.ForwardSetState(SCE_CLW_DEFAULT); + scDoc.Forward(); + } + } + // Picture String State Handling + else if (scDoc.state == SCE_CLW_PICTURE_STRING) { + // If the character is an ( (open parenthese) + if (scDoc.ch == '(') { + // Increment the parenthese level + iParenthesesLevel++; + } + // Else if the character is a ) (close parenthese) + else if (scDoc.ch == ')') { + // If the parenthese level is set to zero + // parentheses matched + if (!iParenthesesLevel) { + scDoc.SetState(SCE_CLW_DEFAULT); + } + // Else parenthese level is greater than zero + // still looking for matching parentheses + else { + // Decrement the parenthese level + iParenthesesLevel--; + } + } + } + // Standard Equate State Handling + else if (scDoc.state == SCE_CLW_STANDARD_EQUATE) { + if (!isalnum(scDoc.ch)) { + scDoc.SetState(SCE_CLW_DEFAULT); + } + } + // Integer Constant State Handling + else if (scDoc.state == SCE_CLW_INTEGER_CONSTANT) { + // If the character is not a digit (0-9) + // or character is not a hexidecimal character (A-F) + // or character is not a . (point) + // or character is not a numberic base character (B,O,H) + if (!(isdigit(scDoc.ch) + || IsAHexCharacter(scDoc.ch, bCaseSensitive) + || scDoc.ch == '.' + || IsANumericBaseCharacter(scDoc.ch, bCaseSensitive))) { + // If the number was a real + if (SetNumericConstantState(scDoc)) { + // Colour the matched string to the real constant state + scDoc.ChangeState(SCE_CLW_REAL_CONSTANT); + } + // Else the number was an integer + else { + // Colour the matched string to an integer constant state + scDoc.ChangeState(SCE_CLW_INTEGER_CONSTANT); + } + // Terminate the integer constant state and set to default state + scDoc.SetState(SCE_CLW_DEFAULT); + } + } + + // + // Determine if a new state should be entered. + // + + // Beginning of Line Handling + if (scDoc.atLineStart) { + // Reset the column 1 label flag + iColumn1Label = false; + // If column 1 character is a label start character + if (IsALabelStart(scDoc.ch)) { + // Label character is found in column 1 + // so set column 1 label flag and clear last column 1 label + iColumn1Label = true; + // Set the state to label + scDoc.SetState(SCE_CLW_LABEL); + } + // else if character is a space or tab + else if (IsASpace(scDoc.ch)){ + // Set to default state + scDoc.SetState(SCE_CLW_DEFAULT); + } + // else if comment start (!) or is an * (asterisk) + else if (IsACommentStart(scDoc.ch) || scDoc.ch == '*' ) { + // then set the state to comment. + scDoc.SetState(SCE_CLW_COMMENT); + } + // else the character is a ? (question mark) + else if (scDoc.ch == '?') { + // Change to the compiler directive state, move forward, + // colouring the ? (question mark), change back to default state. + scDoc.ChangeState(SCE_CLW_COMPILER_DIRECTIVE); + scDoc.Forward(); + scDoc.SetState(SCE_CLW_DEFAULT); + } + // else an invalid character in column 1 + else { + // Set to error state + scDoc.SetState(SCE_CLW_ERROR); + } + } + // End of Line Handling + else if (scDoc.atLineEnd) { + // Reset to the default state at the end of each line. + scDoc.SetState(SCE_CLW_DEFAULT); + } + // Default Handling + else { + // If in default state + if (scDoc.state == SCE_CLW_DEFAULT) { + // If is a letter could be a possible statement + if (isalpha(scDoc.ch)) { + // Set the state to Clarion Keyword and verify later + scDoc.SetState(SCE_CLW_KEYWORD); + } + // else is a number + else if (isdigit(scDoc.ch)) { + // Set the state to Integer Constant and verify later + scDoc.SetState(SCE_CLW_INTEGER_CONSTANT); + } + // else if the start of a comment or a | (line continuation) + else if (IsACommentStart(scDoc.ch) || scDoc.ch == '|') { + // then set the state to comment. + scDoc.SetState(SCE_CLW_COMMENT); + } + // else if the character is a ' (single quote) + else if (scDoc.ch == '\'') { + // If the character is also a ' (single quote) + // Embedded Apostrophe + if (scDoc.chNext == '\'') { + // Move forward colouring it as default state + scDoc.ForwardSetState(SCE_CLW_DEFAULT); + } + else { + // move to the next character and then set the state to comment. + scDoc.ForwardSetState(SCE_CLW_STRING); + } + } + // else the character is an @ (ampersand) + else if (scDoc.ch == '@') { + // Case insensitive. + if (!bCaseSensitive) { + // If character is a valid picture token character + if (strchr("DEKNPSTdeknpst", scDoc.chNext) != NULL) { + // Set to the picture string state + scDoc.SetState(SCE_CLW_PICTURE_STRING); + } + } + // Case sensitive + else { + // If character is a valid picture token character + if (strchr("DEKNPST", scDoc.chNext) != NULL) { + // Set the picture string state + scDoc.SetState(SCE_CLW_PICTURE_STRING); + } + } + } + } + } + } + // lexing complete + scDoc.Complete(); +} + +// Clarion Language Case Sensitive Colouring Procedure +static void ColouriseClarionDocSensitive(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) { + + ColouriseClarionDoc(uiStartPos, iLength, iInitStyle, wlKeywords, accStyler, true); +} + +// Clarion Language Case Insensitive Colouring Procedure +static void ColouriseClarionDocInsensitive(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) { + + ColouriseClarionDoc(uiStartPos, iLength, iInitStyle, wlKeywords, accStyler, false); +} + +// Fill Buffer + +static void FillBuffer(unsigned int uiStart, unsigned int uiEnd, Accessor &accStyler, char *szBuffer, unsigned int uiLength) { + + unsigned int uiPos = 0; + + while ((uiPos < uiEnd - uiStart + 1) && (uiPos < uiLength-1)) { + szBuffer[uiPos] = static_cast(toupper(accStyler[uiStart + uiPos])); + uiPos++; + } + szBuffer[uiPos] = '\0'; +} + +// Classify Clarion Fold Point + +static int ClassifyClarionFoldPoint(int iLevel, const char* szString) { + + if (!(isdigit(szString[0]) || (szString[0] == '.'))) { + if (strcmp(szString, "PROCEDURE") == 0) { + // iLevel = SC_FOLDLEVELBASE + 1; + } + else if (strcmp(szString, "MAP") == 0 || + strcmp(szString,"ACCEPT") == 0 || + strcmp(szString,"BEGIN") == 0 || + strcmp(szString,"CASE") == 0 || + strcmp(szString,"EXECUTE") == 0 || + strcmp(szString,"IF") == 0 || + strcmp(szString,"ITEMIZE") == 0 || + strcmp(szString,"INTERFACE") == 0 || + strcmp(szString,"JOIN") == 0 || + strcmp(szString,"LOOP") == 0 || + strcmp(szString,"MODULE") == 0 || + strcmp(szString,"RECORD") == 0) { + iLevel++; + } + else if (strcmp(szString, "APPLICATION") == 0 || + strcmp(szString, "CLASS") == 0 || + strcmp(szString, "DETAIL") == 0 || + strcmp(szString, "FILE") == 0 || + strcmp(szString, "FOOTER") == 0 || + strcmp(szString, "FORM") == 0 || + strcmp(szString, "GROUP") == 0 || + strcmp(szString, "HEADER") == 0 || + strcmp(szString, "INTERFACE") == 0 || + strcmp(szString, "MENU") == 0 || + strcmp(szString, "MENUBAR") == 0 || + strcmp(szString, "OLE") == 0 || + strcmp(szString, "OPTION") == 0 || + strcmp(szString, "QUEUE") == 0 || + strcmp(szString, "REPORT") == 0 || + strcmp(szString, "SHEET") == 0 || + strcmp(szString, "TAB") == 0 || + strcmp(szString, "TOOLBAR") == 0 || + strcmp(szString, "VIEW") == 0 || + strcmp(szString, "WINDOW") == 0) { + iLevel++; + } + else if (strcmp(szString, "END") == 0 || + strcmp(szString, "UNTIL") == 0 || + strcmp(szString, "WHILE") == 0) { + iLevel--; + } + } + return(iLevel); +} + +// Clarion Language Folding Procedure +static void FoldClarionDoc(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *[], Accessor &accStyler) { + + unsigned int uiEndPos = uiStartPos + iLength; + int iLineCurrent = accStyler.GetLine(uiStartPos); + int iLevelPrev = accStyler.LevelAt(iLineCurrent) & SC_FOLDLEVELNUMBERMASK; + int iLevelCurrent = iLevelPrev; + char chNext = accStyler[uiStartPos]; + int iStyle = iInitStyle; + int iStyleNext = accStyler.StyleAt(uiStartPos); + int iVisibleChars = 0; + int iLastStart = 0; + + for (unsigned int uiPos = uiStartPos; uiPos < uiEndPos; uiPos++) { + + char chChar = chNext; + chNext = accStyler.SafeGetCharAt(uiPos + 1); + int iStylePrev = iStyle; + iStyle = iStyleNext; + iStyleNext = accStyler.StyleAt(uiPos + 1); + bool bEOL = (chChar == '\r' && chNext != '\n') || (chChar == '\n'); + + if (iStylePrev == SCE_CLW_DEFAULT) { + if (iStyle == SCE_CLW_KEYWORD || iStyle == SCE_CLW_STRUCTURE_DATA_TYPE) { + // Store last word start point. + iLastStart = uiPos; + } + } + + if (iStylePrev == SCE_CLW_KEYWORD || iStylePrev == SCE_CLW_STRUCTURE_DATA_TYPE) { + if(iswordchar(chChar) && !iswordchar(chNext)) { + char chBuffer[100]; + FillBuffer(iLastStart, uiPos, accStyler, chBuffer, sizeof(chBuffer)); + iLevelCurrent = ClassifyClarionFoldPoint(iLevelCurrent,chBuffer); + // if ((iLevelCurrent == SC_FOLDLEVELBASE + 1) && iLineCurrent > 1) { + // accStyler.SetLevel(iLineCurrent-1,SC_FOLDLEVELBASE); + // iLevelPrev = SC_FOLDLEVELBASE; + // } + } + } + + if (bEOL) { + int iLevel = iLevelPrev; + if ((iLevelCurrent > iLevelPrev) && (iVisibleChars > 0)) + iLevel |= SC_FOLDLEVELHEADERFLAG; + if (iLevel != accStyler.LevelAt(iLineCurrent)) { + accStyler.SetLevel(iLineCurrent,iLevel); + } + iLineCurrent++; + iLevelPrev = iLevelCurrent; + iVisibleChars = 0; + } + + if (!isspacechar(chChar)) + iVisibleChars++; + } + + // Fill in the real level of the next line, keeping the current flags + // as they will be filled in later. + int iFlagsNext = accStyler.LevelAt(iLineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + accStyler.SetLevel(iLineCurrent, iLevelPrev | iFlagsNext); +} + +// Word List Descriptions +static const char * const rgWordListDescriptions[] = { + "Clarion Keywords", + "Compiler Directives", + "Built-in Procedures and Functions", + "Runtime Expressions", + "Structure and Data Types", + "Attributes", + "Standard Equates", + "Reserved Words (Labels)", + "Reserved Words (Procedure Labels)", + 0, +}; + +// Case Sensitive Clarion Language Lexer +LexerModule lmClw(SCLEX_CLW, ColouriseClarionDocSensitive, "clarion", FoldClarionDoc, rgWordListDescriptions); + +// Case Insensitive Clarion Language Lexer +LexerModule lmClwNoCase(SCLEX_CLWNOCASE, ColouriseClarionDocInsensitive, "clarionnocase", FoldClarionDoc, rgWordListDescriptions); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCOBOL.cxx b/sdk/wxscintilla/src/scintilla/src/LexCOBOL.cxx new file mode 100644 index 0000000..cd42e3e --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCOBOL.cxx @@ -0,0 +1,368 @@ +// Scintilla source code edit control +/** @file LexCOBOL.cxx + ** Lexer for COBOL + ** Based on LexPascal.cxx + ** Written by Laurent le Tynevez + ** Updated by Simon Steele September 2002 + ** Updated by Mathias Rauen May 2003 (Delphi adjustments) + ** Updated by Rod Falck, Aug 2006 Converted to COBOL + **/ + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "StyleContext.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +#define IN_DIVISION 0x01 +#define IN_DECLARATIVES 0x02 +#define IN_SECTION 0x04 +#define IN_PARAGRAPH 0x08 +#define IN_FLAGS 0xF +#define NOT_HEADER 0x10 + +inline bool isCOBOLoperator(char ch) + { + return isoperator(ch); + } + +inline bool isCOBOLwordchar(char ch) + { + return isascii(ch) && (isalnum(ch) || ch == '-'); + + } + +inline bool isCOBOLwordstart(char ch) + { + return isascii(ch) && isalnum(ch); + } + +static int CountBits(int nBits) + { + int count = 0; + for (int i = 0; i < 32; ++i) + { + count += nBits & 1; + nBits >>= 1; + } + return count; + } + +static void getRange(unsigned int start, + unsigned int end, + Accessor &styler, + char *s, + unsigned int len) { + unsigned int i = 0; + while ((i < end - start + 1) && (i < len-1)) { + s[i] = static_cast(tolower(styler[start + i])); + i++; + } + s[i] = '\0'; +} + +static void ColourTo(Accessor &styler, unsigned int end, unsigned int attr) { + styler.ColourTo(end, attr); +} + + +static int classifyWordCOBOL(unsigned int start, unsigned int end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, int nContainment, bool *bAarea) { + int ret = 0; + + WordList& a_keywords = *keywordlists[0]; + WordList& b_keywords = *keywordlists[1]; + WordList& c_keywords = *keywordlists[2]; + + char s[100]; + getRange(start, end, styler, s, sizeof(s)); + + char chAttr = SCE_C_IDENTIFIER; + if (isdigit(s[0]) || (s[0] == '.')) { + chAttr = SCE_C_NUMBER; + char *p = s + 1; + while (*p) { + if (!isdigit(*p) && isCOBOLwordchar(*p)) { + chAttr = SCE_C_IDENTIFIER; + break; + } + ++p; + } + } + else { + if (a_keywords.InList(s)) { + chAttr = SCE_C_WORD; + } + else if (b_keywords.InList(s)) { + chAttr = SCE_C_WORD2; + } + else if (c_keywords.InList(s)) { + chAttr = SCE_C_UUID; + } + } + if (*bAarea) { + if (strcmp(s, "division") == 0) { + ret = IN_DIVISION; + // we've determined the containment, anything else is just ignored for those purposes + *bAarea = false; + } else if (strcmp(s, "declaratives") == 0) { + ret = IN_DIVISION | IN_DECLARATIVES; + if (nContainment & IN_DECLARATIVES) + ret |= NOT_HEADER | IN_SECTION; + // we've determined the containment, anything else is just ignored for those purposes + *bAarea = false; + } else if (strcmp(s, "section") == 0) { + ret = (nContainment &~ IN_PARAGRAPH) | IN_SECTION; + // we've determined the containment, anything else is just ignored for those purposes + *bAarea = false; + } else if (strcmp(s, "end") == 0 && (nContainment & IN_DECLARATIVES)) { + ret = IN_DIVISION | IN_DECLARATIVES | IN_SECTION | NOT_HEADER; + } else { + ret = nContainment | IN_PARAGRAPH; + } + } + ColourTo(styler, end, chAttr); + return ret; +} + +static void ColouriseCOBOLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + + styler.StartAt(startPos); + + int state = initStyle; + if (state == SCE_C_CHARACTER) // Does not leak onto next line + state = SCE_C_DEFAULT; + char chPrev = ' '; + char chNext = styler[startPos]; + unsigned int lengthDoc = startPos + length; + + int nContainment; + + int currentLine = styler.GetLine(startPos); + if (currentLine > 0) { + styler.SetLineState(currentLine, styler.GetLineState(currentLine-1)); + nContainment = styler.GetLineState(currentLine); + nContainment &= ~NOT_HEADER; + } else { + styler.SetLineState(currentLine, 0); + nContainment = 0; + } + + styler.StartSegment(startPos); + bool bNewLine = true; + bool bAarea = !isspacechar(chNext); + int column = 0; + for (unsigned int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + + chNext = styler.SafeGetCharAt(i + 1); + + ++column; + + if (bNewLine) { + column = 0; + } + if (column <= 1 && !bAarea) { + bAarea = !isspacechar(ch); + } + bool bSetNewLine = false; + if ((ch == '\r' && chNext != '\n') || (ch == '\n')) { + // Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix) + // Avoid triggering two times on Dos/Win + // End of line + if (state == SCE_C_CHARACTER) { + ColourTo(styler, i, state); + state = SCE_C_DEFAULT; + } + styler.SetLineState(currentLine, nContainment); + currentLine++; + bSetNewLine = true; + if (nContainment & NOT_HEADER) + nContainment &= ~(NOT_HEADER | IN_DECLARATIVES | IN_SECTION); + } + + if (styler.IsLeadByte(ch)) { + chNext = styler.SafeGetCharAt(i + 2); + chPrev = ' '; + i += 1; + continue; + } + + if (state == SCE_C_DEFAULT) { + if (isCOBOLwordstart(ch) || (ch == '$' && isascii(chNext) && isalpha(chNext))) { + ColourTo(styler, i-1, state); + state = SCE_C_IDENTIFIER; + } else if (column == 0 && ch == '*' && chNext != '*') { + ColourTo(styler, i-1, state); + state = SCE_C_COMMENTLINE; + } else if (column == 0 && ch == '/' && chNext != '*') { + ColourTo(styler, i-1, state); + state = SCE_C_COMMENTLINE; + } else if (column == 0 && ch == '*' && chNext == '*') { + ColourTo(styler, i-1, state); + state = SCE_C_COMMENTDOC; + } else if (column == 0 && ch == '/' && chNext == '*') { + ColourTo(styler, i-1, state); + state = SCE_C_COMMENTDOC; + } else if (ch == '"') { + ColourTo(styler, i-1, state); + state = SCE_C_STRING; + } else if (ch == '\'') { + ColourTo(styler, i-1, state); + state = SCE_C_CHARACTER; + } else if (ch == '?' && column == 0) { + ColourTo(styler, i-1, state); + state = SCE_C_PREPROCESSOR; + } else if (isCOBOLoperator(ch)) { + ColourTo(styler, i-1, state); + ColourTo(styler, i, SCE_C_OPERATOR); + } + } else if (state == SCE_C_IDENTIFIER) { + if (!isCOBOLwordchar(ch)) { + int lStateChange = classifyWordCOBOL(styler.GetStartSegment(), i - 1, keywordlists, styler, nContainment, &bAarea); + + if(lStateChange != 0) { + styler.SetLineState(currentLine, lStateChange); + nContainment = lStateChange; + } + + state = SCE_C_DEFAULT; + chNext = styler.SafeGetCharAt(i + 1); + if (ch == '"') { + state = SCE_C_STRING; + } else if (ch == '\'') { + state = SCE_C_CHARACTER; + } else if (isCOBOLoperator(ch)) { + ColourTo(styler, i, SCE_C_OPERATOR); + } + } + } else { + if (state == SCE_C_PREPROCESSOR) { + if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) { + ColourTo(styler, i-1, state); + state = SCE_C_DEFAULT; + } + } else if (state == SCE_C_COMMENT) { + if (ch == '\r' || ch == '\n') { + ColourTo(styler, i, state); + state = SCE_C_DEFAULT; + } + } else if (state == SCE_C_COMMENTDOC) { + if (ch == '\r' || ch == '\n') { + if (((i > styler.GetStartSegment() + 2) || ( + (initStyle == SCE_C_COMMENTDOC) && + (styler.GetStartSegment() == static_cast(startPos))))) { + ColourTo(styler, i, state); + state = SCE_C_DEFAULT; + } + } + } else if (state == SCE_C_COMMENTLINE) { + if (ch == '\r' || ch == '\n') { + ColourTo(styler, i-1, state); + state = SCE_C_DEFAULT; + } + } else if (state == SCE_C_STRING) { + if (ch == '"') { + ColourTo(styler, i, state); + state = SCE_C_DEFAULT; + } + } else if (state == SCE_C_CHARACTER) { + if (ch == '\'') { + ColourTo(styler, i, state); + state = SCE_C_DEFAULT; + } + } + } + chPrev = ch; + bNewLine = bSetNewLine; + if (bNewLine) + { + bAarea = false; + } + } + ColourTo(styler, lengthDoc - 1, state); +} + +static void FoldCOBOLDoc(unsigned int startPos, int length, int, WordList *[], + Accessor &styler) { + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = lineCurrent > 0 ? styler.LevelAt(lineCurrent - 1) & SC_FOLDLEVELNUMBERMASK : 0xFFF; + char chNext = styler[startPos]; + + bool bNewLine = true; + bool bAarea = !isspacechar(chNext); + int column = 0; + bool bComment = false; + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + ++column; + + if (bNewLine) { + column = 0; + bComment = (ch == '*' || ch == '/' || ch == '?'); + } + if (column <= 1 && !bAarea) { + bAarea = !isspacechar(ch); + } + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (atEOL) { + int nContainment = styler.GetLineState(lineCurrent); + int lev = CountBits(nContainment & IN_FLAGS) | SC_FOLDLEVELBASE; + if (bAarea && !bComment) + --lev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((bAarea) && (visibleChars > 0) && !(nContainment & NOT_HEADER) && !bComment) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + if ((lev & SC_FOLDLEVELNUMBERMASK) <= (levelPrev & SC_FOLDLEVELNUMBERMASK)) { + // this level is at the same level or less than the previous line + // therefore these is nothing for the previous header to collapse, so remove the header + styler.SetLevel(lineCurrent - 1, levelPrev & ~SC_FOLDLEVELHEADERFLAG); + } + levelPrev = lev; + visibleChars = 0; + bAarea = false; + bNewLine = true; + lineCurrent++; + } else { + bNewLine = false; + } + + + if (!isspacechar(ch)) + visibleChars++; + } + + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +static const char * const COBOLWordListDesc[] = { + "A Keywords", + "B Keywords", + "Extended Keywords", + 0 +}; + +LexerModule lmCOBOL(SCLEX_COBOL, ColouriseCOBOLDoc, "COBOL", FoldCOBOLDoc, COBOLWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCPP.cxx b/sdk/wxscintilla/src/scintilla/src/LexCPP.cxx new file mode 100644 index 0000000..7f816fa --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCPP.cxx @@ -0,0 +1,519 @@ +// Scintilla source code edit control +/** @file LexCPP.cxx + ** Lexer for C++, C, Java, and JavaScript. + **/ +// Copyright 1998-2005 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "CharacterSet.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static bool IsSpaceEquiv(int state) { + return (state <= SCE_C_COMMENTDOC) || + // including SCE_C_DEFAULT, SCE_C_COMMENT, SCE_C_COMMENTLINE + (state == SCE_C_COMMENTLINEDOC) || (state == SCE_C_COMMENTDOCKEYWORD) || + (state == SCE_C_COMMENTDOCKEYWORDERROR); +} + +// Preconditions: sc.currentPos points to a character after '+' or '-'. +// The test for pos reaching 0 should be redundant, +// and is in only for safety measures. +// Limitation: this code will give the incorrect answer for code like +// a = b+++/ptn/... +// Putting a space between the '++' post-inc operator and the '+' binary op +// fixes this, and is highly recommended for readability anyway. +static bool FollowsPostfixOperator(StyleContext &sc, Accessor &styler) { + int pos = (int) sc.currentPos; + while (--pos > 0) { + char ch = styler[pos]; + if (ch == '+' || ch == '-') { + return styler[pos - 1] == ch; + } + } + return false; +} + +static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler, bool caseSensitive) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + WordList &keywords4 = *keywordlists[3]; + + // property styling.within.preprocessor + // For C++ code, determines whether all preprocessor code is styled in the preprocessor style (0, the default) + // or only from the initial # to the end of the command word(1). + bool stylingWithinPreprocessor = styler.GetPropertyInt("styling.within.preprocessor") != 0; + + CharacterSet setOKBeforeRE(CharacterSet::setNone, "([{=,:;!%^&*|?~+-"); + CharacterSet setCouldBePostOp(CharacterSet::setNone, "+-"); + + CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\\&<>#{}[]"); + + CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true); + CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true); + + // property lexer.cpp.allow.dollars + // Set to 0 to disallow the '$' character in identifiers with the cpp lexer. + if (styler.GetPropertyInt("lexer.cpp.allow.dollars", 1) != 0) { + setWordStart.Add('$'); + setWord.Add('$'); + } + + int chPrevNonWhite = ' '; + int visibleChars = 0; + bool lastWordWasUUID = false; + bool lastOpSetScope = false; + int styleBeforeDCKeyword = SCE_C_DEFAULT; + bool continuationLine = false; + bool isIncludePreprocessor = false; + + if (initStyle == SCE_C_PREPROCESSOR) { + // Set continuationLine if last character of previous line is '\' + int lineCurrent = styler.GetLine(startPos); + if (lineCurrent > 0) { + int chBack = styler.SafeGetCharAt(startPos-1, 0); + int chBack2 = styler.SafeGetCharAt(startPos-2, 0); + int lineEndChar = '!'; + if (chBack2 == '\r' && chBack == '\n') { + lineEndChar = styler.SafeGetCharAt(startPos-3, 0); + } else if (chBack == '\n' || chBack == '\r') { + lineEndChar = chBack2; + } + continuationLine = lineEndChar == '\\'; + } + } + + // look back to set chPrevNonWhite properly for better regex colouring + if (startPos > 0) { + int back = startPos; + while (--back && IsSpaceEquiv(styler.StyleAt(back))) + ; + if (styler.StyleAt(back) == SCE_C_OPERATOR) { + chPrevNonWhite = styler.SafeGetCharAt(back); + } + } + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + if (sc.atLineStart) { + if (sc.state == SCE_C_STRING) { + // Prevent SCE_C_STRINGEOL from leaking back to previous line which + // ends with a line continuation by locking in the state upto this position. + sc.SetState(SCE_C_STRING); + } + // Reset states to begining of colourise so no surprises + // if different sets of lines lexed. + visibleChars = 0; + lastWordWasUUID = false; + isIncludePreprocessor = false; + } + + // Handle line continuation generically. + if (sc.ch == '\\') { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + continuationLine = true; + continue; + } + } + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_C_OPERATOR: + sc.SetState(SCE_C_DEFAULT); + break; + case SCE_C_NUMBER: + // We accept almost anything because of hex. and number suffixes + if (!setWord.Contains(sc.ch)) { + sc.SetState(SCE_C_DEFAULT); + } + break; + case SCE_C_IDENTIFIER: + if (!setWord.Contains(sc.ch) || (sc.ch == '.')) { + char s[1000]; + if (caseSensitive) { + sc.GetCurrent(s, sizeof(s)); + } else { + sc.GetCurrentLowered(s, sizeof(s)); + } + if (keywords.InList(s)) { + lastWordWasUUID = strcmp(s, "uuid") == 0; + sc.ChangeState(SCE_C_WORD); + } else if (!lastOpSetScope && keywords4.InList(s)) { + sc.ChangeState(SCE_C_GLOBALCLASS); + } else if (!lastOpSetScope && keywords2.InList(s)) { + sc.ChangeState(SCE_C_WORD2); + } else { + lastOpSetScope = false; + } + sc.SetState(SCE_C_DEFAULT); + } + break; + case SCE_C_PREPROCESSOR: + if (sc.atLineStart && !continuationLine) { + sc.SetState(SCE_C_DEFAULT); + } else if (stylingWithinPreprocessor) { + if (IsASpace(sc.ch)) { + sc.SetState(SCE_C_DEFAULT); + } + } else { + if (sc.Match('/', '*') || sc.Match('/', '/')) { + sc.SetState(SCE_C_DEFAULT); + } + } + break; + case SCE_C_COMMENT: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_C_DEFAULT); + } + break; + case SCE_C_COMMENTDOC: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_C_DEFAULT); + } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support + // Verify that we have the conditions to mark a comment-doc-keyword + if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) { + styleBeforeDCKeyword = SCE_C_COMMENTDOC; + sc.SetState(SCE_C_COMMENTDOCKEYWORD); + } + } + break; + case SCE_C_COMMENTLINE: + if (sc.atLineStart) { + sc.SetState(SCE_C_DEFAULT); + } + break; + case SCE_C_COMMENTLINEDOC: + if (sc.atLineStart) { + sc.SetState(SCE_C_DEFAULT); + } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support + // Verify that we have the conditions to mark a comment-doc-keyword + if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) { + styleBeforeDCKeyword = SCE_C_COMMENTLINEDOC; + sc.SetState(SCE_C_COMMENTDOCKEYWORD); + } + } + break; + case SCE_C_COMMENTDOCKEYWORD: + if ((styleBeforeDCKeyword == SCE_C_COMMENTDOC) && sc.Match('*', '/')) { + sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR); + sc.Forward(); + sc.ForwardSetState(SCE_C_DEFAULT); + } else if (!setDoxygen.Contains(sc.ch)) { + char s[100]; + if (caseSensitive) { + sc.GetCurrent(s, sizeof(s)); + } else { + sc.GetCurrentLowered(s, sizeof(s)); + } + if (!IsASpace(sc.ch) || !keywords3.InList(s + 1)) { + sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR); + } + sc.SetState(styleBeforeDCKeyword); + } + break; + case SCE_C_STRING: + if (sc.atLineEnd) { + sc.ChangeState(SCE_C_STRINGEOL); + } else if (isIncludePreprocessor) { + if (sc.ch == '>') { + sc.ForwardSetState(SCE_C_DEFAULT); + isIncludePreprocessor = false; + } + } else if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\"') { + sc.ForwardSetState(SCE_C_DEFAULT); + } + break; + case SCE_C_CHARACTER: + if (sc.atLineEnd) { + sc.ChangeState(SCE_C_STRINGEOL); + } else if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\'') { + sc.ForwardSetState(SCE_C_DEFAULT); + } + break; + case SCE_C_REGEX: + if (sc.atLineStart) { + sc.SetState(SCE_C_DEFAULT); + } else if (sc.ch == '/') { + sc.Forward(); + while ((sc.ch < 0x80) && islower(sc.ch)) + sc.Forward(); // gobble regex flags + sc.SetState(SCE_C_DEFAULT); + } else if (sc.ch == '\\') { + // Gobble up the quoted character + if (sc.chNext == '\\' || sc.chNext == '/') { + sc.Forward(); + } + } + break; + case SCE_C_STRINGEOL: + if (sc.atLineStart) { + sc.SetState(SCE_C_DEFAULT); + } + break; + case SCE_C_VERBATIM: + if (sc.ch == '\"') { + if (sc.chNext == '\"') { + sc.Forward(); + } else { + sc.ForwardSetState(SCE_C_DEFAULT); + } + } + break; + case SCE_C_UUID: + if (sc.ch == '\r' || sc.ch == '\n' || sc.ch == ')') { + sc.SetState(SCE_C_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_C_DEFAULT) { + if (sc.Match('@', '\"')) { + sc.SetState(SCE_C_VERBATIM); + sc.Forward(); + } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + if (lastWordWasUUID) { + sc.SetState(SCE_C_UUID); + lastWordWasUUID = false; + } else { + sc.SetState(SCE_C_NUMBER); + } + } else if (setWordStart.Contains(sc.ch) || (sc.ch == '@')) { + if (lastWordWasUUID) { + sc.SetState(SCE_C_UUID); + lastWordWasUUID = false; + } else { + sc.SetState(SCE_C_IDENTIFIER); + } + } else if (sc.Match('/', '*')) { + if (sc.Match("/**") || sc.Match("/*!")) { // Support of Qt/Doxygen doc. style + sc.SetState(SCE_C_COMMENTDOC); + } else { + sc.SetState(SCE_C_COMMENT); + } + sc.Forward(); // Eat the * so it isn't used for the end of the comment + } else if (sc.Match('/', '/')) { + if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!")) + // Support of Qt/Doxygen doc. style + sc.SetState(SCE_C_COMMENTLINEDOC); + else + sc.SetState(SCE_C_COMMENTLINE); + } else if (sc.ch == '/' && setOKBeforeRE.Contains(chPrevNonWhite) && + (!setCouldBePostOp.Contains(chPrevNonWhite) || !FollowsPostfixOperator(sc, styler))) { + sc.SetState(SCE_C_REGEX); // JavaScript's RegEx + } else if (sc.ch == '\"') { + sc.SetState(SCE_C_STRING); + isIncludePreprocessor = false; // ensure that '>' won't end the string + } else if (isIncludePreprocessor && sc.ch == '<') { + sc.SetState(SCE_C_STRING); + } else if (sc.ch == '\'') { + sc.SetState(SCE_C_CHARACTER); + } else if (sc.ch == '#' && visibleChars == 0) { + // Preprocessor commands are alone on their line + sc.SetState(SCE_C_PREPROCESSOR); + // Skip whitespace between # and preprocessor word + do { + sc.Forward(); + } while ((sc.ch == ' ' || sc.ch == '\t') && sc.More()); + if (sc.atLineEnd) { + sc.SetState(SCE_C_DEFAULT); + } else if (sc.Match("include")) { + isIncludePreprocessor = true; + } + } else if (isoperator(static_cast(sc.ch))) { + sc.SetState(SCE_C_OPERATOR); + lastOpSetScope = false; + if (sc.Match('.') || sc.Match(':', ':') || sc.Match('-', '>') || sc.Match(':', '~')) { + // check for operators '.', '::', and '->' (but not '.*', '::*', or '->*') + if (sc.ch != '.') sc.Forward(); + if (sc.chNext != '*') + lastOpSetScope = true; + else + sc.Forward(); + } + } + } + + if (sc.state != SCE_C_OPERATOR && sc.state != SCE_C_IDENTIFIER) lastOpSetScope = false; + if (!IsASpace(sc.ch) && !IsSpaceEquiv(sc.state)) { + chPrevNonWhite = sc.ch; + visibleChars++; + } + continuationLine = false; + } + sc.Complete(); +} + +static bool IsStreamCommentStyle(int style) { + return style == SCE_C_COMMENT || + style == SCE_C_COMMENTDOC || + style == SCE_C_COMMENTDOCKEYWORD || + style == SCE_C_COMMENTDOCKEYWORDERROR; +} + +// Store both the current line's fold level and the next lines in the +// level store to make it easy to pick up with each increment +// and to make it possible to fiddle the current level for "} else {". +static void FoldCppDoc(unsigned int startPos, int length, int initStyle, + WordList *[], Accessor &styler) { + + // property fold.comment + // This option enables folding multi-line comments and explicit fold points when using the C++ lexer. + // Explicit fold points allows adding extra folding by placing a //{ comment at the start and a //} + // at the end of a section that should fold. + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + + // property fold.preprocessor + // This option enables folding preprocessor directives when using the C++ lexer. + // Includes C#'s explicit #region and #endregion folding directives. + bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0; + + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + + // property fold.at.else + // This option enables C++ folding on a "} else {" line of an if statement. + bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0; + + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelCurrent = SC_FOLDLEVELBASE; + if (lineCurrent > 0) + levelCurrent = styler.LevelAt(lineCurrent-1) >> 16; + int levelMinCurrent = levelCurrent; + int levelNext = levelCurrent; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (foldComment && IsStreamCommentStyle(style)) { + if (!IsStreamCommentStyle(stylePrev) && (stylePrev != SCE_C_COMMENTLINEDOC)) { + levelNext++; + } else if (!IsStreamCommentStyle(styleNext) && (styleNext != SCE_C_COMMENTLINEDOC) && !atEOL) { + // Comments don't end at end of line and the next character may be unstyled. + levelNext--; + } + } + if (foldComment && (style == SCE_C_COMMENTLINE)) { + if ((ch == '/') && (chNext == '/')) { + char chNext2 = styler.SafeGetCharAt(i + 2); + if (chNext2 == '{') { + levelNext++; + } else if (chNext2 == '}') { + levelNext--; + } + } + } + if (foldPreprocessor && (style == SCE_C_PREPROCESSOR)) { + if (ch == '#') { + unsigned int j = i + 1; + while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) { + j++; + } + if (styler.Match(j, "region") || styler.Match(j, "if")) { + levelNext++; + } else if (styler.Match(j, "end")) { + levelNext--; + } + } + } + if (style == SCE_C_OPERATOR) { + if (ch == '{') { + // Measure the minimum before a '{' to allow + // folding on "} else {" + if (levelMinCurrent > levelNext) { + levelMinCurrent = levelNext; + } + levelNext++; + } else if (ch == '}') { + levelNext--; + } + } + if (!IsASpace(ch)) + visibleChars++; + if (atEOL || (i == endPos-1)) { + int levelUse = levelCurrent; + if (foldAtElse) { + levelUse = levelMinCurrent; + } + int lev = levelUse | levelNext << 16; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if (levelUse < levelNext) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelCurrent = levelNext; + levelMinCurrent = levelCurrent; + if (atEOL && (i == static_cast(styler.Length()-1))) { + // There is an empty line at end of file so give it same level and empty + styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG); + } + visibleChars = 0; + } + } +} + +static const char * const cppWordLists[] = { + "Primary keywords and identifiers", + "Secondary keywords and identifiers", + "Documentation comment keywords", + "Unused", + "Global classes and typedefs", + 0, + }; + +static void ColouriseCppDocSensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + ColouriseCppDoc(startPos, length, initStyle, keywordlists, styler, true); +} + +static void ColouriseCppDocInsensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + ColouriseCppDoc(startPos, length, initStyle, keywordlists, styler, false); +} + +LexerModule lmCPP(SCLEX_CPP, ColouriseCppDocSensitive, "cpp", FoldCppDoc, cppWordLists); +LexerModule lmCPPNoCase(SCLEX_CPPNOCASE, ColouriseCppDocInsensitive, "cppnocase", FoldCppDoc, cppWordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCSS.cxx b/sdk/wxscintilla/src/scintilla/src/LexCSS.cxx new file mode 100644 index 0000000..f63103d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCSS.cxx @@ -0,0 +1,371 @@ +// Scintilla source code edit control +/** @file LexCSS.cxx + ** Lexer for Cascading Style Sheets + ** Written by Jakub Vrna + ** Improved by Philippe Lhoste (CSS2) + **/ +// Copyright 1998-2002 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + + +static inline bool IsAWordChar(const unsigned int ch) { + /* FIXME: + * The CSS spec allows "ISO 10646 characters U+00A1 and higher" to be treated as word chars. + * Unfortunately, we are only getting string bytes here, and not full unicode characters. We cannot guarantee + * that our byte is between U+0080 - U+00A0 (to return false), so we have to allow all characters U+0080 and higher + */ + return ch >= 0x80 || isalnum(ch) || ch == '-' || ch == '_'; +} + +inline bool IsCssOperator(const int ch) { + if (!((ch < 0x80) && isalnum(ch)) && + (ch == '{' || ch == '}' || ch == ':' || ch == ',' || ch == ';' || + ch == '.' || ch == '#' || ch == '!' || ch == '@' || + /* CSS2 */ + ch == '*' || ch == '>' || ch == '+' || ch == '=' || ch == '~' || ch == '|' || + ch == '[' || ch == ']' || ch == '(' || ch == ')')) { + return true; + } + return false; +} + +static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) { + WordList &css1Props = *keywordlists[0]; + WordList &pseudoClasses = *keywordlists[1]; + WordList &css2Props = *keywordlists[2]; + WordList &css3Props = *keywordlists[3]; + WordList &pseudoElements = *keywordlists[4]; + WordList &exProps = *keywordlists[5]; + WordList &exPseudoClasses = *keywordlists[6]; + WordList &exPseudoElements = *keywordlists[7]; + + StyleContext sc(startPos, length, initStyle, styler); + + int lastState = -1; // before operator + int lastStateC = -1; // before comment + int lastStateS = -1; // before single-quoted/double-quoted string + int op = ' '; // last operator + int opPrev = ' '; // last operator + + for (; sc.More(); sc.Forward()) { + if (sc.state == SCE_CSS_COMMENT && sc.Match('*', '/')) { + if (lastStateC == -1) { + // backtrack to get last state: + // comments are like whitespace, so we must return to the previous state + unsigned int i = startPos; + for (; i > 0; i--) { + if ((lastStateC = styler.StyleAt(i-1)) != SCE_CSS_COMMENT) { + if (lastStateC == SCE_CSS_OPERATOR) { + op = styler.SafeGetCharAt(i-1); + opPrev = styler.SafeGetCharAt(i-2); + while (--i) { + lastState = styler.StyleAt(i-1); + if (lastState != SCE_CSS_OPERATOR && lastState != SCE_CSS_COMMENT) + break; + } + if (i == 0) + lastState = SCE_CSS_DEFAULT; + } + break; + } + } + if (i == 0) + lastStateC = SCE_CSS_DEFAULT; + } + sc.Forward(); + sc.ForwardSetState(lastStateC); + } + + if (sc.state == SCE_CSS_COMMENT) + continue; + + if (sc.state == SCE_CSS_DOUBLESTRING || sc.state == SCE_CSS_SINGLESTRING) { + if (sc.ch != (sc.state == SCE_CSS_DOUBLESTRING ? '\"' : '\'')) + continue; + unsigned int i = sc.currentPos; + while (i && styler[i-1] == '\\') + i--; + if ((sc.currentPos - i) % 2 == 1) + continue; + sc.ForwardSetState(lastStateS); + } + + if (sc.state == SCE_CSS_OPERATOR) { + if (op == ' ') { + unsigned int i = startPos; + op = styler.SafeGetCharAt(i-1); + opPrev = styler.SafeGetCharAt(i-2); + while (--i) { + lastState = styler.StyleAt(i-1); + if (lastState != SCE_CSS_OPERATOR && lastState != SCE_CSS_COMMENT) + break; + } + } + switch (op) { + case '@': + if (lastState == SCE_CSS_DEFAULT) + sc.SetState(SCE_CSS_DIRECTIVE); + break; + case '>': + case '+': + if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID || + lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS) + sc.SetState(SCE_CSS_DEFAULT); + break; + case '[': + if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID || + lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS) + sc.SetState(SCE_CSS_ATTRIBUTE); + break; + case ']': + if (lastState == SCE_CSS_ATTRIBUTE) + sc.SetState(SCE_CSS_TAG); + break; + case '{': + if (lastState == SCE_CSS_MEDIA) + sc.SetState(SCE_CSS_DEFAULT); + else if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DIRECTIVE) + sc.SetState(SCE_CSS_IDENTIFIER); + break; + case '}': + if (lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_VALUE || lastState == SCE_CSS_IMPORTANT || + lastState == SCE_CSS_IDENTIFIER || lastState == SCE_CSS_IDENTIFIER2 || lastState == SCE_CSS_IDENTIFIER3) + sc.SetState(SCE_CSS_DEFAULT); + break; + case '(': + if (lastState == SCE_CSS_PSEUDOCLASS) + sc.SetState(SCE_CSS_TAG); + else if (lastState == SCE_CSS_EXTENDED_PSEUDOCLASS) + sc.SetState(SCE_CSS_EXTENDED_PSEUDOCLASS); + break; + case ')': + if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID || + lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS || + lastState == SCE_CSS_PSEUDOELEMENT || lastState == SCE_CSS_EXTENDED_PSEUDOELEMENT) + sc.SetState(SCE_CSS_TAG); + break; + case ':': + if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID || + lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS || + lastState == SCE_CSS_PSEUDOELEMENT || lastState == SCE_CSS_EXTENDED_PSEUDOELEMENT) + sc.SetState(SCE_CSS_PSEUDOCLASS); + else if (lastState == SCE_CSS_IDENTIFIER || lastState == SCE_CSS_IDENTIFIER2 || + lastState == SCE_CSS_IDENTIFIER3 || lastState == SCE_CSS_EXTENDED_IDENTIFIER || + lastState == SCE_CSS_UNKNOWN_IDENTIFIER) + sc.SetState(SCE_CSS_VALUE); + break; + case '.': + if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID || + lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS) + sc.SetState(SCE_CSS_CLASS); + break; + case '#': + if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID || + lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS) + sc.SetState(SCE_CSS_ID); + break; + case ',': + case '|': + case '~': + if (lastState == SCE_CSS_TAG) + sc.SetState(SCE_CSS_DEFAULT); + break; + case ';': + if (lastState == SCE_CSS_DIRECTIVE) + sc.SetState(SCE_CSS_DEFAULT); + else if (lastState == SCE_CSS_VALUE || lastState == SCE_CSS_IMPORTANT) + sc.SetState(SCE_CSS_IDENTIFIER); + break; + case '!': + if (lastState == SCE_CSS_VALUE) + sc.SetState(SCE_CSS_IMPORTANT); + break; + } + } + + if (IsAWordChar(sc.ch)) { + if (sc.state == SCE_CSS_DEFAULT) + sc.SetState(SCE_CSS_TAG); + continue; + } + + if (sc.ch == '*' && sc.state == SCE_CSS_DEFAULT) { + sc.SetState(SCE_CSS_TAG); + continue; + } + + if (IsAWordChar(sc.chPrev) && ( + sc.state == SCE_CSS_IDENTIFIER || sc.state == SCE_CSS_IDENTIFIER2 || + sc.state == SCE_CSS_IDENTIFIER3 || sc.state == SCE_CSS_EXTENDED_IDENTIFIER || + sc.state == SCE_CSS_UNKNOWN_IDENTIFIER || + sc.state == SCE_CSS_PSEUDOCLASS || sc.state == SCE_CSS_PSEUDOELEMENT || + sc.state == SCE_CSS_EXTENDED_PSEUDOCLASS || sc.state == SCE_CSS_EXTENDED_PSEUDOELEMENT || + sc.state == SCE_CSS_UNKNOWN_PSEUDOCLASS || + sc.state == SCE_CSS_IMPORTANT || + sc.state == SCE_CSS_DIRECTIVE + )) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + char *s2 = s; + while (*s2 && !IsAWordChar(*s2)) + s2++; + switch (sc.state) { + case SCE_CSS_IDENTIFIER: + case SCE_CSS_IDENTIFIER2: + case SCE_CSS_IDENTIFIER3: + case SCE_CSS_EXTENDED_IDENTIFIER: + case SCE_CSS_UNKNOWN_IDENTIFIER: + if (css1Props.InList(s2)) + sc.ChangeState(SCE_CSS_IDENTIFIER); + else if (css2Props.InList(s2)) + sc.ChangeState(SCE_CSS_IDENTIFIER2); + else if (css3Props.InList(s2)) + sc.ChangeState(SCE_CSS_IDENTIFIER3); + else if (exProps.InList(s2)) + sc.ChangeState(SCE_CSS_EXTENDED_IDENTIFIER); + else + sc.ChangeState(SCE_CSS_UNKNOWN_IDENTIFIER); + break; + case SCE_CSS_PSEUDOCLASS: + case SCE_CSS_PSEUDOELEMENT: + case SCE_CSS_EXTENDED_PSEUDOCLASS: + case SCE_CSS_EXTENDED_PSEUDOELEMENT: + case SCE_CSS_UNKNOWN_PSEUDOCLASS: + if (op == ':' && opPrev != ':' && pseudoClasses.InList(s2)) + sc.ChangeState(SCE_CSS_PSEUDOCLASS); + else if (opPrev == ':' && pseudoElements.InList(s2)) + sc.ChangeState(SCE_CSS_PSEUDOELEMENT); + else if ((op == ':' || (op == '(' && lastState == SCE_CSS_EXTENDED_PSEUDOCLASS)) && opPrev != ':' && exPseudoClasses.InList(s2)) + sc.ChangeState(SCE_CSS_EXTENDED_PSEUDOCLASS); + else if (opPrev == ':' && exPseudoElements.InList(s2)) + sc.ChangeState(SCE_CSS_EXTENDED_PSEUDOELEMENT); + else + sc.ChangeState(SCE_CSS_UNKNOWN_PSEUDOCLASS); + break; + case SCE_CSS_IMPORTANT: + if (strcmp(s2, "important") != 0) + sc.ChangeState(SCE_CSS_VALUE); + break; + case SCE_CSS_DIRECTIVE: + if (op == '@' && strcmp(s2, "media") == 0) + sc.ChangeState(SCE_CSS_MEDIA); + break; + } + } + + if (sc.ch != '.' && sc.ch != ':' && sc.ch != '#' && ( + sc.state == SCE_CSS_CLASS || sc.state == SCE_CSS_ID || + (sc.ch != '(' && sc.ch != ')' && ( /* This line of the condition makes it possible to extend pseudo-classes with parentheses */ + sc.state == SCE_CSS_PSEUDOCLASS || sc.state == SCE_CSS_PSEUDOELEMENT || + sc.state == SCE_CSS_EXTENDED_PSEUDOCLASS || sc.state == SCE_CSS_EXTENDED_PSEUDOELEMENT || + sc.state == SCE_CSS_UNKNOWN_PSEUDOCLASS + )) + )) + sc.SetState(SCE_CSS_TAG); + + if (sc.Match('/', '*')) { + lastStateC = sc.state; + sc.SetState(SCE_CSS_COMMENT); + sc.Forward(); + } else if ((sc.state == SCE_CSS_VALUE || sc.state == SCE_CSS_ATTRIBUTE) + && (sc.ch == '\"' || sc.ch == '\'')) { + lastStateS = sc.state; + sc.SetState((sc.ch == '\"' ? SCE_CSS_DOUBLESTRING : SCE_CSS_SINGLESTRING)); + } else if (IsCssOperator(sc.ch) + && (sc.state != SCE_CSS_ATTRIBUTE || sc.ch == ']') + && (sc.state != SCE_CSS_VALUE || sc.ch == ';' || sc.ch == '}' || sc.ch == '!') + && ((sc.state != SCE_CSS_DIRECTIVE && sc.state != SCE_CSS_MEDIA) || sc.ch == ';' || sc.ch == '{') + ) { + if (sc.state != SCE_CSS_OPERATOR) + lastState = sc.state; + sc.SetState(SCE_CSS_OPERATOR); + op = sc.ch; + opPrev = sc.chPrev; + } + } + + sc.Complete(); +} + +static void FoldCSSDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) { + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + bool inComment = (styler.StyleAt(startPos-1) == SCE_CSS_COMMENT); + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int style = styler.StyleAt(i); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (foldComment) { + if (!inComment && (style == SCE_CSS_COMMENT)) + levelCurrent++; + else if (inComment && (style != SCE_CSS_COMMENT)) + levelCurrent--; + inComment = (style == SCE_CSS_COMMENT); + } + if (style == SCE_CSS_OPERATOR) { + if (ch == '{') { + levelCurrent++; + } else if (ch == '}') { + levelCurrent--; + } + } + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) + visibleChars++; + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +static const char * const cssWordListDesc[] = { + "CSS1 Properties", + "Pseudo-classes", + "CSS2 Properties", + "CSS3 Properties", + "Pseudo-elements", + "Browser-Specific CSS Properties", + "Browser-Specific Pseudo-classes", + "Browser-Specific Pseudo-elements", + 0 +}; + +LexerModule lmCss(SCLEX_CSS, ColouriseCssDoc, "css", FoldCSSDoc, cssWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCaml.cxx b/sdk/wxscintilla/src/scintilla/src/LexCaml.cxx new file mode 100644 index 0000000..ca1b65f --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCaml.cxx @@ -0,0 +1,449 @@ +// Scintilla source code edit control +/** @file LexCaml.cxx + ** Lexer for Objective Caml. + **/ +// Copyright 2005-2009 by Robert Roessler +// The License.txt file describes the conditions under which this software may be distributed. +/* Release History + 20050204 Initial release. + 20050205 Quick compiler standards/"cleanliness" adjustment. + 20050206 Added cast for IsLeadByte(). + 20050209 Changes to "external" build support. + 20050306 Fix for 1st-char-in-doc "corner" case. + 20050502 Fix for [harmless] one-past-the-end coloring. + 20050515 Refined numeric token recognition logic. + 20051125 Added 2nd "optional" keywords class. + 20051129 Support "magic" (read-only) comments for RCaml. + 20051204 Swtich to using StyleContext infrastructure. + 20090629 Add full Standard ML '97 support. +*/ + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "PropSetSimple.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +// Since the Microsoft __iscsym[f] funcs are not ANSI... +inline int iscaml(int c) {return isalnum(c) || c == '_';} +inline int iscamlf(int c) {return isalpha(c) || c == '_';} + +static const int baseT[24] = { + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A - L */ + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0,16 /* M - X */ +}; + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +#ifdef BUILD_AS_EXTERNAL_LEXER +/* + (actually seems to work!) +*/ +#include "WindowAccessor.h" +#include "ExternalLexer.h" + +#if PLAT_WIN +#include +#endif + +static void ColouriseCamlDoc( + unsigned int startPos, int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler); + +static void FoldCamlDoc( + unsigned int startPos, int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler); + +static void InternalLexOrFold(int lexOrFold, unsigned int startPos, int length, + int initStyle, char *words[], WindowID window, char *props); + +static const char* LexerName = "caml"; + +#ifdef TRACE +void Platform::DebugPrintf(const char *format, ...) { + char buffer[2000]; + va_list pArguments; + va_start(pArguments, format); + vsprintf(buffer,format,pArguments); + va_end(pArguments); + Platform::DebugDisplay(buffer); +} +#else +void Platform::DebugPrintf(const char *, ...) { +} +#endif + +bool Platform::IsDBCSLeadByte(int codePage, char ch) { + return ::IsDBCSLeadByteEx(codePage, ch) != 0; +} + +long Platform::SendScintilla(WindowID w, unsigned int msg, unsigned long wParam, long lParam) { + return ::SendMessage(reinterpret_cast(w), msg, wParam, lParam); +} + +long Platform::SendScintillaPointer(WindowID w, unsigned int msg, unsigned long wParam, void *lParam) { + return ::SendMessage(reinterpret_cast(w), msg, wParam, + reinterpret_cast(lParam)); +} + +void EXT_LEXER_DECL Fold(unsigned int lexer, unsigned int startPos, int length, + int initStyle, char *words[], WindowID window, char *props) +{ + // below useless evaluation(s) to supress "not used" warnings + lexer; + // build expected data structures and do the Fold + InternalLexOrFold(1, startPos, length, initStyle, words, window, props); + +} + +int EXT_LEXER_DECL GetLexerCount() +{ + return 1; // just us [Objective] Caml lexers here! +} + +void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength) +{ + // below useless evaluation(s) to supress "not used" warnings + Index; + // return as much of our lexer name as will fit (what's up with Index?) + if (buflength > 0) { + buflength--; + int n = strlen(LexerName); + if (n > buflength) + n = buflength; + memcpy(name, LexerName, n), name[n] = '\0'; + } +} + +void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length, + int initStyle, char *words[], WindowID window, char *props) +{ + // below useless evaluation(s) to supress "not used" warnings + lexer; + // build expected data structures and do the Lex + InternalLexOrFold(0, startPos, length, initStyle, words, window, props); +} + +static void InternalLexOrFold(int foldOrLex, unsigned int startPos, int length, + int initStyle, char *words[], WindowID window, char *props) +{ + // create and initialize a WindowAccessor (including contained PropSet) + PropSetSimple ps; + ps.SetMultiple(props); + WindowAccessor wa(window, ps); + // create and initialize WordList(s) + int nWL = 0; + for (; words[nWL]; nWL++) ; // count # of WordList PTRs needed + WordList** wl = new WordList* [nWL + 1];// alloc WordList PTRs + int i = 0; + for (; i < nWL; i++) { + wl[i] = new WordList(); // (works or THROWS bad_alloc EXCEPTION) + wl[i]->Set(words[i]); + } + wl[i] = 0; + // call our "internal" folder/lexer (... then do Flush!) + if (foldOrLex) + FoldCamlDoc(startPos, length, initStyle, wl, wa); + else + ColouriseCamlDoc(startPos, length, initStyle, wl, wa); + wa.Flush(); + // clean up before leaving + for (i = nWL - 1; i >= 0; i--) + delete wl[i]; + delete [] wl; +} + +static +#endif /* BUILD_AS_EXTERNAL_LEXER */ + +void ColouriseCamlDoc( + unsigned int startPos, int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler) +{ + // initialize styler + StyleContext sc(startPos, length, initStyle, styler); + + int chBase = 0, chToken = 0, chLit = 0; + WordList& keywords = *keywordlists[0]; + WordList& keywords2 = *keywordlists[1]; + WordList& keywords3 = *keywordlists[2]; + const bool isSML = keywords.InList("andalso"); + const int useMagic = styler.GetPropertyInt("lexer.caml.magic", 0); + + // set up [initial] state info (terminating states that shouldn't "bleed") + const int state_ = sc.state & 0x0f; + if (state_ <= SCE_CAML_CHAR + || (isSML && state_ == SCE_CAML_STRING)) + sc.state = SCE_CAML_DEFAULT; + int nesting = (state_ >= SCE_CAML_COMMENT)? (state_ - SCE_CAML_COMMENT): 0; + + // foreach char in range... + while (sc.More()) { + // set up [per-char] state info + int state2 = -1; // (ASSUME no state change) + int chColor = sc.currentPos - 1;// (ASSUME standard coloring range) + bool advance = true; // (ASSUME scanner "eats" 1 char) + + // step state machine + switch (sc.state & 0x0f) { + case SCE_CAML_DEFAULT: + chToken = sc.currentPos; // save [possible] token start (JIC) + // it's wide open; what do we have? + if (iscamlf(sc.ch)) + state2 = SCE_CAML_IDENTIFIER; + else if (!isSML && sc.Match('`') && iscamlf(sc.chNext)) + state2 = SCE_CAML_TAGNAME; + else if (!isSML && sc.Match('#') && isdigit(sc.chNext)) + state2 = SCE_CAML_LINENUM; + else if (isdigit(sc.ch)) { + // it's a number, assume base 10 + state2 = SCE_CAML_NUMBER, chBase = 10; + if (sc.Match('0')) { + // there MAY be a base specified... + const char* baseC = "bBoOxX"; + if (isSML) { + if (sc.chNext == 'w') + sc.Forward(); // (consume SML "word" indicator) + baseC = "x"; + } + // ... change to specified base AS REQUIRED + if (strchr(baseC, sc.chNext)) + chBase = baseT[tolower(sc.chNext) - 'a'], sc.Forward(); + } + } else if (!isSML && sc.Match('\'')) // (Caml char literal?) + state2 = SCE_CAML_CHAR, chLit = 0; + else if (isSML && sc.Match('#', '"')) // (SML char literal?) + state2 = SCE_CAML_CHAR, sc.Forward(); + else if (sc.Match('"')) + state2 = SCE_CAML_STRING; + else if (sc.Match('(', '*')) + state2 = SCE_CAML_COMMENT, sc.Forward(), sc.ch = ' '; // (*)... + else if (strchr("!?~" /* Caml "prefix-symbol" */ + "=<>@^|&+-*/$%" /* Caml "infix-symbol" */ + "()[]{};,:.#", sc.ch) // Caml "bracket" or ;,:.# + // SML "extra" ident chars + || (isSML && (sc.Match('\\') || sc.Match('`')))) + state2 = SCE_CAML_OPERATOR; + break; + + case SCE_CAML_IDENTIFIER: + // [try to] interpret as [additional] identifier char + if (!(iscaml(sc.ch) || sc.Match('\''))) { + const int n = sc.currentPos - chToken; + if (n < 24) { + // length is believable as keyword, [re-]construct token + char t[24]; + for (int i = -n; i < 0; i++) + t[n + i] = static_cast(sc.GetRelative(i)); + t[n] = '\0'; + // special-case "_" token as KEYWORD + if ((n == 1 && sc.chPrev == '_') || keywords.InList(t)) + sc.ChangeState(SCE_CAML_KEYWORD); + else if (keywords2.InList(t)) + sc.ChangeState(SCE_CAML_KEYWORD2); + else if (keywords3.InList(t)) + sc.ChangeState(SCE_CAML_KEYWORD3); + } + state2 = SCE_CAML_DEFAULT, advance = false; + } + break; + + case SCE_CAML_TAGNAME: + // [try to] interpret as [additional] tagname char + if (!(iscaml(sc.ch) || sc.Match('\''))) + state2 = SCE_CAML_DEFAULT, advance = false; + break; + + /*case SCE_CAML_KEYWORD: + case SCE_CAML_KEYWORD2: + case SCE_CAML_KEYWORD3: + // [try to] interpret as [additional] keyword char + if (!iscaml(ch)) + state2 = SCE_CAML_DEFAULT, advance = false; + break;*/ + + case SCE_CAML_LINENUM: + // [try to] interpret as [additional] linenum directive char + if (!isdigit(sc.ch)) + state2 = SCE_CAML_DEFAULT, advance = false; + break; + + case SCE_CAML_OPERATOR: { + // [try to] interpret as [additional] operator char + const char* o = 0; + if (iscaml(sc.ch) || isspace(sc.ch) // ident or whitespace + || (o = strchr(")]};,\'\"#", sc.ch),o) // "termination" chars + || (!isSML && sc.Match('`')) // Caml extra term char + || (!strchr("!$%&*+-./:<=>?@^|~", sc.ch)// "operator" chars + // SML extra ident chars + && !(isSML && (sc.Match('\\') || sc.Match('`'))))) { + // check for INCLUSIVE termination + if (o && strchr(")]};,", sc.ch)) { + if ((sc.Match(')') && sc.chPrev == '(') + || (sc.Match(']') && sc.chPrev == '[')) + // special-case "()" and "[]" tokens as KEYWORDS + sc.ChangeState(SCE_CAML_KEYWORD); + chColor++; + } else + advance = false; + state2 = SCE_CAML_DEFAULT; + } + break; + } + + case SCE_CAML_NUMBER: + // [try to] interpret as [additional] numeric literal char + if ((!isSML && sc.Match('_')) || IsADigit(sc.ch, chBase)) + break; + // how about an integer suffix? + if (!isSML && (sc.Match('l') || sc.Match('L') || sc.Match('n')) + && (sc.chPrev == '_' || IsADigit(sc.chPrev, chBase))) + break; + // or a floating-point literal? + if (chBase == 10) { + // with a decimal point? + if (sc.Match('.') + && ((!isSML && sc.chPrev == '_') + || IsADigit(sc.chPrev, chBase))) + break; + // with an exponent? (I) + if ((sc.Match('e') || sc.Match('E')) + && ((!isSML && (sc.chPrev == '.' || sc.chPrev == '_')) + || IsADigit(sc.chPrev, chBase))) + break; + // with an exponent? (II) + if (((!isSML && (sc.Match('+') || sc.Match('-'))) + || (isSML && sc.Match('~'))) + && (sc.chPrev == 'e' || sc.chPrev == 'E')) + break; + } + // it looks like we have run out of number + state2 = SCE_CAML_DEFAULT, advance = false; + break; + + case SCE_CAML_CHAR: + if (!isSML) { + // [try to] interpret as [additional] char literal char + if (sc.Match('\\')) { + chLit = 1; // (definitely IS a char literal) + if (sc.chPrev == '\\') + sc.ch = ' '; // (...\\') + // should we be terminating - one way or another? + } else if ((sc.Match('\'') && sc.chPrev != '\\') + || sc.atLineEnd) { + state2 = SCE_CAML_DEFAULT; + if (sc.Match('\'')) + chColor++; + else + sc.ChangeState(SCE_CAML_IDENTIFIER); + // ... maybe a char literal, maybe not + } else if (chLit < 1 && sc.currentPos - chToken >= 2) + sc.ChangeState(SCE_CAML_IDENTIFIER), advance = false; + break; + }/* else + // fall through for SML char literal (handle like string) */ + + case SCE_CAML_STRING: + // [try to] interpret as [additional] [SML char/] string literal char + if (isSML && sc.Match('\\') && sc.chPrev != '\\' && isspace(sc.chNext)) + state2 = SCE_CAML_WHITE; + else if (sc.Match('\\') && sc.chPrev == '\\') + sc.ch = ' '; // (...\\") + // should we be terminating - one way or another? + else if ((sc.Match('"') && sc.chPrev != '\\') + || (isSML && sc.atLineEnd)) { + state2 = SCE_CAML_DEFAULT; + if (sc.Match('"')) + chColor++; + } + break; + + case SCE_CAML_WHITE: + // [try to] interpret as [additional] SML embedded whitespace char + if (sc.Match('\\')) { + // style this puppy NOW... + state2 = SCE_CAML_STRING, sc.ch = ' ' /* (...\") */, chColor++, + styler.ColourTo(chColor, SCE_CAML_WHITE), styler.Flush(); + // ... then backtrack to determine original SML literal type + int p = chColor - 2; + for (; p >= 0 && styler.StyleAt(p) == SCE_CAML_WHITE; p--) ; + if (p >= 0) + state2 = static_cast(styler.StyleAt(p)); + // take care of state change NOW + sc.ChangeState(state2), state2 = -1; + } + break; + + case SCE_CAML_COMMENT: + case SCE_CAML_COMMENT1: + case SCE_CAML_COMMENT2: + case SCE_CAML_COMMENT3: + // we're IN a comment - does this start a NESTED comment? + if (sc.Match('(', '*')) + state2 = sc.state + 1, chToken = sc.currentPos, + sc.Forward(), sc.ch = ' ' /* (*)... */, nesting++; + // [try to] interpret as [additional] comment char + else if (sc.Match(')') && sc.chPrev == '*') { + if (nesting) + state2 = (sc.state & 0x0f) - 1, chToken = 0, nesting--; + else + state2 = SCE_CAML_DEFAULT; + chColor++; + // enable "magic" (read-only) comment AS REQUIRED + } else if (useMagic && sc.currentPos - chToken == 4 + && sc.Match('c') && sc.chPrev == 'r' && sc.GetRelative(-2) == '@') + sc.state |= 0x10; // (switch to read-only comment style) + break; + } + + // handle state change and char coloring AS REQUIRED + if (state2 >= 0) + styler.ColourTo(chColor, sc.state), sc.ChangeState(state2); + // move to next char UNLESS re-scanning current char + if (advance) + sc.Forward(); + } + + // do any required terminal char coloring (JIC) + sc.Complete(); +} + +#ifdef BUILD_AS_EXTERNAL_LEXER +static +#endif /* BUILD_AS_EXTERNAL_LEXER */ +void FoldCamlDoc( + unsigned int, int, + int, + WordList *[], + Accessor &) +{ +} + +static const char * const camlWordListDesc[] = { + "Keywords", // primary Objective Caml keywords + "Keywords2", // "optional" keywords (typically from Pervasives) + "Keywords3", // "optional" keywords (typically typenames) + 0 +}; + +#ifndef BUILD_AS_EXTERNAL_LEXER +LexerModule lmCaml(SCLEX_CAML, ColouriseCamlDoc, "caml", FoldCamlDoc, camlWordListDesc); +#endif /* BUILD_AS_EXTERNAL_LEXER */ diff --git a/sdk/wxscintilla/src/scintilla/src/LexCmake.cxx b/sdk/wxscintilla/src/scintilla/src/LexCmake.cxx new file mode 100644 index 0000000..1f51f47 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCmake.cxx @@ -0,0 +1,457 @@ +// Scintilla source code edit control +/** @file LexCmake.cxx + ** Lexer for Cmake + **/ +// Copyright 2007 by Cristian Adam +// based on the NSIS lexer +// The License.txt file describes the conditions under which this software may be distributed. +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "CharClassify.h" +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static bool isCmakeNumber(char ch) +{ + return(ch >= '0' && ch <= '9'); +} + +static bool isCmakeChar(char ch) +{ + return(ch == '.' ) || (ch == '_' ) || isCmakeNumber(ch) || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'); +} + +static bool isCmakeLetter(char ch) +{ + return(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'); +} + +static bool CmakeNextLineHasElse(unsigned int start, unsigned int end, Accessor &styler) +{ + int nNextLine = -1; + for ( unsigned int i = start; i < end; i++ ) { + char cNext = styler.SafeGetCharAt( i ); + if ( cNext == '\n' ) { + nNextLine = i+1; + break; + } + } + + if ( nNextLine == -1 ) // We never foudn the next line... + return false; + + for ( unsigned int firstChar = nNextLine; firstChar < end; firstChar++ ) { + char cNext = styler.SafeGetCharAt( firstChar ); + if ( cNext == ' ' ) + continue; + if ( cNext == '\t' ) + continue; + if ( styler.Match(firstChar, "ELSE") || styler.Match(firstChar, "else")) + return true; + break; + } + + return false; +} + +static int calculateFoldCmake(unsigned int start, unsigned int end, int foldlevel, Accessor &styler, bool bElse) +{ + // If the word is too long, it is not what we are looking for + if ( end - start > 20 ) + return foldlevel; + + int newFoldlevel = foldlevel; + + char s[20]; // The key word we are looking for has atmost 13 characters + for (unsigned int i = 0; i < end - start + 1 && i < 19; i++) { + s[i] = static_cast( styler[ start + i ] ); + s[i + 1] = '\0'; + } + + if ( CompareCaseInsensitive(s, "IF") == 0 || CompareCaseInsensitive(s, "WHILE") == 0 + || CompareCaseInsensitive(s, "MACRO") == 0 || CompareCaseInsensitive(s, "FOREACH") == 0 + || CompareCaseInsensitive(s, "ELSEIF") == 0 ) + newFoldlevel++; + else if ( CompareCaseInsensitive(s, "ENDIF") == 0 || CompareCaseInsensitive(s, "ENDWHILE") == 0 + || CompareCaseInsensitive(s, "ENDMACRO") == 0 || CompareCaseInsensitive(s, "ENDFOREACH") == 0) + newFoldlevel--; + else if ( bElse && CompareCaseInsensitive(s, "ELSEIF") == 0 ) + newFoldlevel++; + else if ( bElse && CompareCaseInsensitive(s, "ELSE") == 0 ) + newFoldlevel++; + + return newFoldlevel; +} + +static int classifyWordCmake(unsigned int start, unsigned int end, WordList *keywordLists[], Accessor &styler ) +{ + char word[100] = {0}; + char lowercaseWord[100] = {0}; + + WordList &Commands = *keywordLists[0]; + WordList &Parameters = *keywordLists[1]; + WordList &UserDefined = *keywordLists[2]; + + for (unsigned int i = 0; i < end - start + 1 && i < 99; i++) { + word[i] = static_cast( styler[ start + i ] ); + lowercaseWord[i] = static_cast(tolower(word[i])); + } + + // Check for special words... + if ( CompareCaseInsensitive(word, "MACRO") == 0 || CompareCaseInsensitive(word, "ENDMACRO") == 0 ) + return SCE_CMAKE_MACRODEF; + + if ( CompareCaseInsensitive(word, "IF") == 0 || CompareCaseInsensitive(word, "ENDIF") == 0 ) + return SCE_CMAKE_IFDEFINEDEF; + + if ( CompareCaseInsensitive(word, "ELSEIF") == 0 || CompareCaseInsensitive(word, "ELSE") == 0 ) + return SCE_CMAKE_IFDEFINEDEF; + + if ( CompareCaseInsensitive(word, "WHILE") == 0 || CompareCaseInsensitive(word, "ENDWHILE") == 0) + return SCE_CMAKE_WHILEDEF; + + if ( CompareCaseInsensitive(word, "FOREACH") == 0 || CompareCaseInsensitive(word, "ENDFOREACH") == 0) + return SCE_CMAKE_FOREACHDEF; + + if ( Commands.InList(lowercaseWord) ) + return SCE_CMAKE_COMMANDS; + + if ( Parameters.InList(word) ) + return SCE_CMAKE_PARAMETERS; + + + if ( UserDefined.InList(word) ) + return SCE_CMAKE_USERDEFINED; + + if ( strlen(word) > 3 ) { + if ( word[1] == '{' && word[strlen(word)-1] == '}' ) + return SCE_CMAKE_VARIABLE; + } + + // To check for numbers + if ( isCmakeNumber( word[0] ) ) { + bool bHasSimpleCmakeNumber = true; + for (unsigned int j = 1; j < end - start + 1 && j < 99; j++) { + if ( !isCmakeNumber( word[j] ) ) { + bHasSimpleCmakeNumber = false; + break; + } + } + + if ( bHasSimpleCmakeNumber ) + return SCE_CMAKE_NUMBER; + } + + return SCE_CMAKE_DEFAULT; +} + +static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler) +{ + int state = SCE_CMAKE_DEFAULT; + if ( startPos > 0 ) + state = styler.StyleAt(startPos-1); // Use the style from the previous line, usually default, but could be commentbox + + styler.StartAt( startPos ); + styler.GetLine( startPos ); + + unsigned int nLengthDoc = startPos + length; + styler.StartSegment( startPos ); + + char cCurrChar; + bool bVarInString = false; + bool bClassicVarInString = false; + + unsigned int i; + for ( i = startPos; i < nLengthDoc; i++ ) { + cCurrChar = styler.SafeGetCharAt( i ); + char cNextChar = styler.SafeGetCharAt(i+1); + + switch (state) { + case SCE_CMAKE_DEFAULT: + if ( cCurrChar == '#' ) { // we have a comment line + styler.ColourTo(i-1, state ); + state = SCE_CMAKE_COMMENT; + break; + } + if ( cCurrChar == '"' ) { + styler.ColourTo(i-1, state ); + state = SCE_CMAKE_STRINGDQ; + bVarInString = false; + bClassicVarInString = false; + break; + } + if ( cCurrChar == '\'' ) { + styler.ColourTo(i-1, state ); + state = SCE_CMAKE_STRINGRQ; + bVarInString = false; + bClassicVarInString = false; + break; + } + if ( cCurrChar == '`' ) { + styler.ColourTo(i-1, state ); + state = SCE_CMAKE_STRINGLQ; + bVarInString = false; + bClassicVarInString = false; + break; + } + + // CMake Variable + if ( cCurrChar == '$' || isCmakeChar(cCurrChar)) { + styler.ColourTo(i-1,state); + state = SCE_CMAKE_VARIABLE; + + // If it is a number, we must check and set style here first... + if ( isCmakeNumber(cCurrChar) && (cNextChar == '\t' || cNextChar == ' ' || cNextChar == '\r' || cNextChar == '\n' ) ) + styler.ColourTo( i, SCE_CMAKE_NUMBER); + + break; + } + + break; + case SCE_CMAKE_COMMENT: + if ( cNextChar == '\n' || cNextChar == '\r' ) { + // Special case: + if ( cCurrChar == '\\' ) { + styler.ColourTo(i-2,state); + styler.ColourTo(i,SCE_CMAKE_DEFAULT); + } + else { + styler.ColourTo(i,state); + state = SCE_CMAKE_DEFAULT; + } + } + break; + case SCE_CMAKE_STRINGDQ: + case SCE_CMAKE_STRINGLQ: + case SCE_CMAKE_STRINGRQ: + + if ( styler.SafeGetCharAt(i-1) == '\\' && styler.SafeGetCharAt(i-2) == '$' ) + break; // Ignore the next character, even if it is a quote of some sort + + if ( cCurrChar == '"' && state == SCE_CMAKE_STRINGDQ ) { + styler.ColourTo(i,state); + state = SCE_CMAKE_DEFAULT; + break; + } + + if ( cCurrChar == '`' && state == SCE_CMAKE_STRINGLQ ) { + styler.ColourTo(i,state); + state = SCE_CMAKE_DEFAULT; + break; + } + + if ( cCurrChar == '\'' && state == SCE_CMAKE_STRINGRQ ) { + styler.ColourTo(i,state); + state = SCE_CMAKE_DEFAULT; + break; + } + + if ( cNextChar == '\r' || cNextChar == '\n' ) { + int nCurLine = styler.GetLine(i+1); + int nBack = i; + // We need to check if the previous line has a \ in it... + bool bNextLine = false; + + while ( nBack > 0 ) { + if ( styler.GetLine(nBack) != nCurLine ) + break; + + char cTemp = styler.SafeGetCharAt(nBack, 'a'); // Letter 'a' is safe here + + if ( cTemp == '\\' ) { + bNextLine = true; + break; + } + if ( cTemp != '\r' && cTemp != '\n' && cTemp != '\t' && cTemp != ' ' ) + break; + + nBack--; + } + + if ( bNextLine ) { + styler.ColourTo(i+1,state); + } + if ( bNextLine == false ) { + styler.ColourTo(i,state); + state = SCE_CMAKE_DEFAULT; + } + } + break; + + case SCE_CMAKE_VARIABLE: + + // CMake Variable: + if ( cCurrChar == '$' ) + state = SCE_CMAKE_DEFAULT; + else if ( cCurrChar == '\\' && (cNextChar == 'n' || cNextChar == 'r' || cNextChar == 't' ) ) + state = SCE_CMAKE_DEFAULT; + else if ( (isCmakeChar(cCurrChar) && !isCmakeChar( cNextChar) && cNextChar != '}') || cCurrChar == '}' ) { + state = classifyWordCmake( styler.GetStartSegment(), i, keywordLists, styler ); + styler.ColourTo( i, state); + state = SCE_CMAKE_DEFAULT; + } + else if ( !isCmakeChar( cCurrChar ) && cCurrChar != '{' && cCurrChar != '}' ) { + if ( classifyWordCmake( styler.GetStartSegment(), i-1, keywordLists, styler) == SCE_CMAKE_NUMBER ) + styler.ColourTo( i-1, SCE_CMAKE_NUMBER ); + + state = SCE_CMAKE_DEFAULT; + + if ( cCurrChar == '"' ) { + state = SCE_CMAKE_STRINGDQ; + bVarInString = false; + bClassicVarInString = false; + } + else if ( cCurrChar == '`' ) { + state = SCE_CMAKE_STRINGLQ; + bVarInString = false; + bClassicVarInString = false; + } + else if ( cCurrChar == '\'' ) { + state = SCE_CMAKE_STRINGRQ; + bVarInString = false; + bClassicVarInString = false; + } + else if ( cCurrChar == '#' ) { + state = SCE_CMAKE_COMMENT; + } + } + break; + } + + if ( state == SCE_CMAKE_COMMENT) { + styler.ColourTo(i,state); + } + else if ( state == SCE_CMAKE_STRINGDQ || state == SCE_CMAKE_STRINGLQ || state == SCE_CMAKE_STRINGRQ ) { + bool bIngoreNextDollarSign = false; + + if ( bVarInString && cCurrChar == '$' ) { + bVarInString = false; + bIngoreNextDollarSign = true; + } + else if ( bVarInString && cCurrChar == '\\' && (cNextChar == 'n' || cNextChar == 'r' || cNextChar == 't' || cNextChar == '"' || cNextChar == '`' || cNextChar == '\'' ) ) { + styler.ColourTo( i+1, SCE_CMAKE_STRINGVAR); + bVarInString = false; + bIngoreNextDollarSign = false; + } + + else if ( bVarInString && !isCmakeChar(cNextChar) ) { + int nWordState = classifyWordCmake( styler.GetStartSegment(), i, keywordLists, styler); + if ( nWordState == SCE_CMAKE_VARIABLE ) + styler.ColourTo( i, SCE_CMAKE_STRINGVAR); + bVarInString = false; + } + // Covers "${TEST}..." + else if ( bClassicVarInString && cNextChar == '}' ) { + styler.ColourTo( i+1, SCE_CMAKE_STRINGVAR); + bClassicVarInString = false; + } + + // Start of var in string + if ( !bIngoreNextDollarSign && cCurrChar == '$' && cNextChar == '{' ) { + styler.ColourTo( i-1, state); + bClassicVarInString = true; + bVarInString = false; + } + else if ( !bIngoreNextDollarSign && cCurrChar == '$' ) { + styler.ColourTo( i-1, state); + bVarInString = true; + bClassicVarInString = false; + } + } + } + + // Colourise remaining document + styler.ColourTo(nLengthDoc-1,state); +} + +static void FoldCmakeDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) +{ + // No folding enabled, no reason to continue... + if ( styler.GetPropertyInt("fold") == 0 ) + return; + + bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) == 1; + + int lineCurrent = styler.GetLine(startPos); + unsigned int safeStartPos = styler.LineStart( lineCurrent ); + + bool bArg1 = true; + int nWordStart = -1; + + int levelCurrent = SC_FOLDLEVELBASE; + if (lineCurrent > 0) + levelCurrent = styler.LevelAt(lineCurrent-1) >> 16; + int levelNext = levelCurrent; + + for (unsigned int i = safeStartPos; i < startPos + length; i++) { + char chCurr = styler.SafeGetCharAt(i); + + if ( bArg1 ) { + if ( nWordStart == -1 && (isCmakeLetter(chCurr)) ) { + nWordStart = i; + } + else if ( isCmakeLetter(chCurr) == false && nWordStart > -1 ) { + int newLevel = calculateFoldCmake( nWordStart, i-1, levelNext, styler, foldAtElse); + + if ( newLevel == levelNext ) { + if ( foldAtElse ) { + if ( CmakeNextLineHasElse(i, startPos + length, styler) ) + levelNext--; + } + } + else + levelNext = newLevel; + bArg1 = false; + } + } + + if ( chCurr == '\n' ) { + if ( bArg1 && foldAtElse) { + if ( CmakeNextLineHasElse(i, startPos + length, styler) ) + levelNext--; + } + + // If we are on a new line... + int levelUse = levelCurrent; + int lev = levelUse | levelNext << 16; + if (levelUse < levelNext ) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) + styler.SetLevel(lineCurrent, lev); + + lineCurrent++; + levelCurrent = levelNext; + bArg1 = true; // New line, lets look at first argument again + nWordStart = -1; + } + } + + int levelUse = levelCurrent; + int lev = levelUse | levelNext << 16; + if (levelUse < levelNext) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) + styler.SetLevel(lineCurrent, lev); +} + +static const char * const cmakeWordLists[] = { + "Commands", + "Parameters", + "UserDefined", + 0, + 0,}; + +LexerModule lmCmake(SCLEX_CMAKE, ColouriseCmakeDoc, "cmake", FoldCmakeDoc, cmakeWordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexConf.cxx b/sdk/wxscintilla/src/scintilla/src/LexConf.cxx new file mode 100644 index 0000000..7b066af --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexConf.cxx @@ -0,0 +1,188 @@ +// Scintilla source code edit control +/** @file LexConf.cxx + ** Lexer for Apache Configuration Files. + ** + ** First working version contributed by Ahmad Zawawi on October 28, 2000. + ** i created this lexer because i needed something pretty when dealing + ** when Apache Configuration files... + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler) +{ + int state = SCE_CONF_DEFAULT; + char chNext = styler[startPos]; + int lengthDoc = startPos + length; + // create a buffer large enough to take the largest chunk... + char *buffer = new char[length]; + int bufferCount = 0; + + // this assumes that we have 2 keyword list in conf.properties + WordList &directives = *keywordLists[0]; + WordList ¶ms = *keywordLists[1]; + + // go through all provided text segment + // using the hand-written state machine shown below + styler.StartAt(startPos); + styler.StartSegment(startPos); + for (int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + if (styler.IsLeadByte(ch)) { + chNext = styler.SafeGetCharAt(i + 2); + i++; + continue; + } + switch(state) { + case SCE_CONF_DEFAULT: + if( ch == '\n' || ch == '\r' || ch == '\t' || ch == ' ') { + // whitespace is simply ignored here... + styler.ColourTo(i,SCE_CONF_DEFAULT); + break; + } else if( ch == '#' ) { + // signals the start of a comment... + state = SCE_CONF_COMMENT; + styler.ColourTo(i,SCE_CONF_COMMENT); + } else if( ch == '.' /*|| ch == '/'*/) { + // signals the start of a file... + state = SCE_CONF_EXTENSION; + styler.ColourTo(i,SCE_CONF_EXTENSION); + } else if( ch == '"') { + state = SCE_CONF_STRING; + styler.ColourTo(i,SCE_CONF_STRING); + } else if( isascii(ch) && ispunct(ch) ) { + // signals an operator... + // no state jump necessary for this + // simple case... + styler.ColourTo(i,SCE_CONF_OPERATOR); + } else if( isascii(ch) && isalpha(ch) ) { + // signals the start of an identifier + bufferCount = 0; + buffer[bufferCount++] = static_cast(tolower(ch)); + state = SCE_CONF_IDENTIFIER; + } else if( isascii(ch) && isdigit(ch) ) { + // signals the start of a number + bufferCount = 0; + buffer[bufferCount++] = ch; + //styler.ColourTo(i,SCE_CONF_NUMBER); + state = SCE_CONF_NUMBER; + } else { + // style it the default style.. + styler.ColourTo(i,SCE_CONF_DEFAULT); + } + break; + + case SCE_CONF_COMMENT: + // if we find a newline here, + // we simply go to default state + // else continue to work on it... + if( ch == '\n' || ch == '\r' ) { + state = SCE_CONF_DEFAULT; + } else { + styler.ColourTo(i,SCE_CONF_COMMENT); + } + break; + + case SCE_CONF_EXTENSION: + // if we find a non-alphanumeric char, + // we simply go to default state + // else we're still dealing with an extension... + if( (isascii(ch) && isalnum(ch)) || (ch == '_') || + (ch == '-') || (ch == '$') || + (ch == '/') || (ch == '.') || (ch == '*') ) + { + styler.ColourTo(i,SCE_CONF_EXTENSION); + } else { + state = SCE_CONF_DEFAULT; + chNext = styler[i--]; + } + break; + + case SCE_CONF_STRING: + // if we find the end of a string char, we simply go to default state + // else we're still dealing with an string... + if( (ch == '"' && styler.SafeGetCharAt(i-1)!='\\') || (ch == '\n') || (ch == '\r') ) { + state = SCE_CONF_DEFAULT; + } + styler.ColourTo(i,SCE_CONF_STRING); + break; + + case SCE_CONF_IDENTIFIER: + // stay in CONF_IDENTIFIER state until we find a non-alphanumeric + if( (isascii(ch) && isalnum(ch)) || (ch == '_') || (ch == '-') || (ch == '/') || (ch == '$') || (ch == '.') || (ch == '*')) { + buffer[bufferCount++] = static_cast(tolower(ch)); + } else { + state = SCE_CONF_DEFAULT; + buffer[bufferCount] = '\0'; + + // check if the buffer contains a keyword, and highlight it if it is a keyword... + if(directives.InList(buffer)) { + styler.ColourTo(i-1,SCE_CONF_DIRECTIVE ); + } else if(params.InList(buffer)) { + styler.ColourTo(i-1,SCE_CONF_PARAMETER ); + } else if(strchr(buffer,'/') || strchr(buffer,'.')) { + styler.ColourTo(i-1,SCE_CONF_EXTENSION); + } else { + styler.ColourTo(i-1,SCE_CONF_DEFAULT); + } + + // push back the faulty character + chNext = styler[i--]; + + } + break; + + case SCE_CONF_NUMBER: + // stay in CONF_NUMBER state until we find a non-numeric + if( (isascii(ch) && isdigit(ch)) || ch == '.') { + buffer[bufferCount++] = ch; + } else { + state = SCE_CONF_DEFAULT; + buffer[bufferCount] = '\0'; + + // Colourize here... + if( strchr(buffer,'.') ) { + // it is an IP address... + styler.ColourTo(i-1,SCE_CONF_IP); + } else { + // normal number + styler.ColourTo(i-1,SCE_CONF_NUMBER); + } + + // push back a character + chNext = styler[i--]; + } + break; + + } + } + delete []buffer; +} + +static const char * const confWordListDesc[] = { + "Directives", + "Parameters", + 0 +}; + +LexerModule lmConf(SCLEX_CONF, ColouriseConfDoc, "conf", 0, confWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCppCheck.cxx b/sdk/wxscintilla/src/scintilla/src/LexCppCheck.cxx new file mode 100644 index 0000000..40ee781 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCppCheck.cxx @@ -0,0 +1,119 @@ +// Scintilla source code edit control +/** @file LexOthers.cxx + ** Lexers for batch files, diff results, properties files, make files and error lists. + ** Also lexer for LaTeX documents. + **/ +// Copyright 1998-2001 by Eran Ifrah +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "StyleContext.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +typedef int (*CPPCHECK_COLOUR_FUNC_PTR)(int, const char*, size_t&, size_t&); + +static CPPCHECK_COLOUR_FUNC_PTR s_cppcheckColourFunc = NULL; + +void SetCppCheckColourFunction(CPPCHECK_COLOUR_FUNC_PTR func) +{ + s_cppcheckColourFunc = func; +} + +static inline bool AtEOL(Accessor &styler, unsigned int i) +{ + return (styler[i] == '\n') || + ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n')); +} + +static void ColouriseCppCheckDoc( + unsigned int pos, + int length, + int /*initStyle*/, + WordList * /*keywordlists*/[], + Accessor &styler) +{ + std::string line; + line.reserve(2048); + + styler.StartAt(pos); + styler.StartSegment(pos); + + for (; length > 0; pos++, length--) { + line += styler[pos]; + if (AtEOL(styler, pos)) { + // End of line met, colourise it + int style = SCLEX_GCC_OUTPUT; + if (s_cppcheckColourFunc) { + size_t start(0); + size_t len(0); + int startLine = pos-line.size()+1; + style = s_cppcheckColourFunc(startLine, line.c_str(), start, len); + if(len != 0) { + styler.ColourTo(startLine + start - 1, style); + styler.ColourTo(startLine + start + len - 1, SCLEX_GCC_FILE_LINK); + } + } + styler.ColourTo(pos, style); + line.clear(); + } + } +} + +static void FoldCppCheckDoc(unsigned int pos, int length, int, + WordList*[], Accessor &styler) +{ + int curLine = styler.GetLine(pos); + int prevLevel = curLine > 0 ? styler.LevelAt(curLine-1) : SC_FOLDLEVELBASE; + + unsigned int end = pos+length; + pos = styler.LineStart(curLine); + + do { + int nextLevel; + switch (styler.StyleAt(pos)) { + case SCLEX_GCC_BUILDING: + nextLevel = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG; + break; + default: + nextLevel = prevLevel & SC_FOLDLEVELHEADERFLAG ? (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1 : prevLevel; + break; + } + if ((nextLevel & SC_FOLDLEVELHEADERFLAG) && nextLevel == prevLevel) { + styler.SetLevel(curLine-1, prevLevel & ~SC_FOLDLEVELHEADERFLAG); + } + styler.SetLevel(curLine, nextLevel); + + curLine++; + prevLevel = nextLevel; + pos = styler.LineStart(curLine); + } while (pos < end); +} + +static const char * const cppcheckWordListDesc[] = { + "Internal Commands", + "External Commands", + 0 +}; + +static const char * const emptyWordListDesc[] = { + 0 +}; + +LexerModule lmCppCheck(SCLEX_CPPCHECK, ColouriseCppCheckDoc, "cppcheck", FoldCppCheckDoc, cppcheckWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCrontab.cxx b/sdk/wxscintilla/src/scintilla/src/LexCrontab.cxx new file mode 100644 index 0000000..f6c4d42 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCrontab.cxx @@ -0,0 +1,222 @@ +// Scintilla source code edit control +/** @file LexCrontab.cxx + ** Lexer to use with extended crontab files used by a powerful + ** Windows scheduler/event monitor/automation manager nnCron. + ** (http://nemtsev.eserv.ru/) + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static void ColouriseNncrontabDoc(unsigned int startPos, int length, int, WordList +*keywordLists[], Accessor &styler) +{ + int state = SCE_NNCRONTAB_DEFAULT; + char chNext = styler[startPos]; + int lengthDoc = startPos + length; + // create a buffer large enough to take the largest chunk... + char *buffer = new char[length]; + int bufferCount = 0; + // used when highliting environment variables inside quoted string: + bool insideString = false; + + // this assumes that we have 3 keyword list in conf.properties + WordList §ion = *keywordLists[0]; + WordList &keyword = *keywordLists[1]; + WordList &modifier = *keywordLists[2]; + + // go through all provided text segment + // using the hand-written state machine shown below + styler.StartAt(startPos); + styler.StartSegment(startPos); + for (int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + if (styler.IsLeadByte(ch)) { + chNext = styler.SafeGetCharAt(i + 2); + i++; + continue; + } + switch(state) { + case SCE_NNCRONTAB_DEFAULT: + if( ch == '\n' || ch == '\r' || ch == '\t' || ch == ' ') { + // whitespace is simply ignored here... + styler.ColourTo(i,SCE_NNCRONTAB_DEFAULT); + break; + } else if( ch == '#' && styler.SafeGetCharAt(i+1) == '(') { + // signals the start of a task... + state = SCE_NNCRONTAB_TASK; + styler.ColourTo(i,SCE_NNCRONTAB_TASK); + } + else if( ch == '\\' && (styler.SafeGetCharAt(i+1) == ' ' || + styler.SafeGetCharAt(i+1) == '\t')) { + // signals the start of an extended comment... + state = SCE_NNCRONTAB_COMMENT; + styler.ColourTo(i,SCE_NNCRONTAB_COMMENT); + } else if( ch == '#' ) { + // signals the start of a plain comment... + state = SCE_NNCRONTAB_COMMENT; + styler.ColourTo(i,SCE_NNCRONTAB_COMMENT); + } else if( ch == ')' && styler.SafeGetCharAt(i+1) == '#') { + // signals the end of a task... + state = SCE_NNCRONTAB_TASK; + styler.ColourTo(i,SCE_NNCRONTAB_TASK); + } else if( ch == '"') { + state = SCE_NNCRONTAB_STRING; + styler.ColourTo(i,SCE_NNCRONTAB_STRING); + } else if( ch == '%') { + // signals environment variables + state = SCE_NNCRONTAB_ENVIRONMENT; + styler.ColourTo(i,SCE_NNCRONTAB_ENVIRONMENT); + } else if( ch == '<' && styler.SafeGetCharAt(i+1) == '%') { + // signals environment variables + state = SCE_NNCRONTAB_ENVIRONMENT; + styler.ColourTo(i,SCE_NNCRONTAB_ENVIRONMENT); + } else if( ch == '*' ) { + // signals an asterisk + // no state jump necessary for this simple case... + styler.ColourTo(i,SCE_NNCRONTAB_ASTERISK); + } else if( (isascii(ch) && isalpha(ch)) || ch == '<' ) { + // signals the start of an identifier + bufferCount = 0; + buffer[bufferCount++] = ch; + state = SCE_NNCRONTAB_IDENTIFIER; + } else if( isascii(ch) && isdigit(ch) ) { + // signals the start of a number + bufferCount = 0; + buffer[bufferCount++] = ch; + state = SCE_NNCRONTAB_NUMBER; + } else { + // style it the default style.. + styler.ColourTo(i,SCE_NNCRONTAB_DEFAULT); + } + break; + + case SCE_NNCRONTAB_COMMENT: + // if we find a newline here, + // we simply go to default state + // else continue to work on it... + if( ch == '\n' || ch == '\r' ) { + state = SCE_NNCRONTAB_DEFAULT; + } else { + styler.ColourTo(i,SCE_NNCRONTAB_COMMENT); + } + break; + + case SCE_NNCRONTAB_TASK: + // if we find a newline here, + // we simply go to default state + // else continue to work on it... + if( ch == '\n' || ch == '\r' ) { + state = SCE_NNCRONTAB_DEFAULT; + } else { + styler.ColourTo(i,SCE_NNCRONTAB_TASK); + } + break; + + case SCE_NNCRONTAB_STRING: + if( ch == '%' ) { + state = SCE_NNCRONTAB_ENVIRONMENT; + insideString = true; + styler.ColourTo(i-1,SCE_NNCRONTAB_STRING); + break; + } + // if we find the end of a string char, we simply go to default state + // else we're still dealing with an string... + if( (ch == '"' && styler.SafeGetCharAt(i-1)!='\\') || + (ch == '\n') || (ch == '\r') ) { + state = SCE_NNCRONTAB_DEFAULT; + } + styler.ColourTo(i,SCE_NNCRONTAB_STRING); + break; + + case SCE_NNCRONTAB_ENVIRONMENT: + // if we find the end of a string char, we simply go to default state + // else we're still dealing with an string... + if( ch == '%' && insideString ) { + state = SCE_NNCRONTAB_STRING; + insideString = false; + break; + } + if( (ch == '%' && styler.SafeGetCharAt(i-1)!='\\') + || (ch == '\n') || (ch == '\r') || (ch == '>') ) { + state = SCE_NNCRONTAB_DEFAULT; + styler.ColourTo(i,SCE_NNCRONTAB_ENVIRONMENT); + break; + } + styler.ColourTo(i+1,SCE_NNCRONTAB_ENVIRONMENT); + break; + + case SCE_NNCRONTAB_IDENTIFIER: + // stay in CONF_IDENTIFIER state until we find a non-alphanumeric + if( (isascii(ch) && isalnum(ch)) || (ch == '_') || (ch == '-') || (ch == '/') || + (ch == '$') || (ch == '.') || (ch == '<') || (ch == '>') || + (ch == '@') ) { + buffer[bufferCount++] = ch; + } else { + state = SCE_NNCRONTAB_DEFAULT; + buffer[bufferCount] = '\0'; + + // check if the buffer contains a keyword, + // and highlight it if it is a keyword... + if(section.InList(buffer)) { + styler.ColourTo(i,SCE_NNCRONTAB_SECTION ); + } else if(keyword.InList(buffer)) { + styler.ColourTo(i-1,SCE_NNCRONTAB_KEYWORD ); + } // else if(strchr(buffer,'/') || strchr(buffer,'.')) { + // styler.ColourTo(i-1,SCE_NNCRONTAB_EXTENSION); + // } + else if(modifier.InList(buffer)) { + styler.ColourTo(i-1,SCE_NNCRONTAB_MODIFIER ); + } else { + styler.ColourTo(i-1,SCE_NNCRONTAB_DEFAULT); + } + // push back the faulty character + chNext = styler[i--]; + } + break; + + case SCE_NNCRONTAB_NUMBER: + // stay in CONF_NUMBER state until we find a non-numeric + if( isascii(ch) && isdigit(ch) /* || ch == '.' */ ) { + buffer[bufferCount++] = ch; + } else { + state = SCE_NNCRONTAB_DEFAULT; + buffer[bufferCount] = '\0'; + // Colourize here... (normal number) + styler.ColourTo(i-1,SCE_NNCRONTAB_NUMBER); + // push back a character + chNext = styler[i--]; + } + break; + } + } + delete []buffer; +} + +static const char * const cronWordListDesc[] = { + "Section keywords and Forth words", + "nnCrontab keywords", + "Modifiers", + 0 +}; + +LexerModule lmNncrontab(SCLEX_NNCRONTAB, ColouriseNncrontabDoc, "nncrontab", 0, cronWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexCsound.cxx b/sdk/wxscintilla/src/scintilla/src/LexCsound.cxx new file mode 100644 index 0000000..3aa2eb8 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexCsound.cxx @@ -0,0 +1,210 @@ +// Scintilla source code edit control +/** @file LexCsound.cxx + ** Lexer for Csound (Orchestra & Score) + ** Written by Georg Ritter - + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' || + ch == '_' || ch == '?'); +} + +static inline bool IsAWordStart(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' || + ch == '%' || ch == '@' || ch == '$' || ch == '?'); +} + +static inline bool IsCsoundOperator(char ch) { + if (isascii(ch) && isalnum(ch)) + return false; + // '.' left out as it is used to make up numbers + if (ch == '*' || ch == '/' || ch == '-' || ch == '+' || + ch == '(' || ch == ')' || ch == '=' || ch == '^' || + ch == '[' || ch == ']' || ch == '<' || ch == '&' || + ch == '>' || ch == ',' || ch == '|' || ch == '~' || + ch == '%' || ch == ':') + return true; + return false; +} + +static void ColouriseCsoundDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + + WordList &opcode = *keywordlists[0]; + WordList &headerStmt = *keywordlists[1]; + WordList &otherKeyword = *keywordlists[2]; + + // Do not leak onto next line + if (initStyle == SCE_CSOUND_STRINGEOL) + initStyle = SCE_CSOUND_DEFAULT; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) + { + // Handle line continuation generically. + if (sc.ch == '\\') { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + continue; + } + } + + // Determine if the current state should terminate. + if (sc.state == SCE_CSOUND_OPERATOR) { + if (!IsCsoundOperator(static_cast(sc.ch))) { + sc.SetState(SCE_CSOUND_DEFAULT); + } + }else if (sc.state == SCE_CSOUND_NUMBER) { + if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_CSOUND_DEFAULT); + } + } else if (sc.state == SCE_CSOUND_IDENTIFIER) { + if (!IsAWordChar(sc.ch) ) { + char s[100]; + sc.GetCurrent(s, sizeof(s)); + + if (opcode.InList(s)) { + sc.ChangeState(SCE_CSOUND_OPCODE); + } else if (headerStmt.InList(s)) { + sc.ChangeState(SCE_CSOUND_HEADERSTMT); + } else if (otherKeyword.InList(s)) { + sc.ChangeState(SCE_CSOUND_USERKEYWORD); + } else if (s[0] == 'p') { + sc.ChangeState(SCE_CSOUND_PARAM); + } else if (s[0] == 'a') { + sc.ChangeState(SCE_CSOUND_ARATE_VAR); + } else if (s[0] == 'k') { + sc.ChangeState(SCE_CSOUND_KRATE_VAR); + } else if (s[0] == 'i') { // covers both i-rate variables and i-statements + sc.ChangeState(SCE_CSOUND_IRATE_VAR); + } else if (s[0] == 'g') { + sc.ChangeState(SCE_CSOUND_GLOBAL_VAR); + } + sc.SetState(SCE_CSOUND_DEFAULT); + } + } + else if (sc.state == SCE_CSOUND_COMMENT ) { + if (sc.atLineEnd) { + sc.SetState(SCE_CSOUND_DEFAULT); + } + } + else if ((sc.state == SCE_CSOUND_ARATE_VAR) || + (sc.state == SCE_CSOUND_KRATE_VAR) || + (sc.state == SCE_CSOUND_IRATE_VAR)) { + if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_CSOUND_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_CSOUND_DEFAULT) { + if (sc.ch == ';'){ + sc.SetState(SCE_CSOUND_COMMENT); + } else if (isdigit(sc.ch) || (sc.ch == '.' && isdigit(sc.chNext))) { + sc.SetState(SCE_CSOUND_NUMBER); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_CSOUND_IDENTIFIER); + } else if (IsCsoundOperator(static_cast(sc.ch))) { + sc.SetState(SCE_CSOUND_OPERATOR); + } else if (sc.ch == 'p') { + sc.SetState(SCE_CSOUND_PARAM); + } else if (sc.ch == 'a') { + sc.SetState(SCE_CSOUND_ARATE_VAR); + } else if (sc.ch == 'k') { + sc.SetState(SCE_CSOUND_KRATE_VAR); + } else if (sc.ch == 'i') { // covers both i-rate variables and i-statements + sc.SetState(SCE_CSOUND_IRATE_VAR); + } else if (sc.ch == 'g') { + sc.SetState(SCE_CSOUND_GLOBAL_VAR); + } + } + } + sc.Complete(); +} + +static void FoldCsoundInstruments(unsigned int startPos, int length, int /* initStyle */, WordList *[], + Accessor &styler) { + unsigned int lengthDoc = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + int stylePrev = 0; + int styleNext = styler.StyleAt(startPos); + for (unsigned int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if ((stylePrev != SCE_CSOUND_OPCODE) && (style == SCE_CSOUND_OPCODE)) { + char s[20]; + unsigned int j = 0; + while ((j < (sizeof(s) - 1)) && (iswordchar(styler[i + j]))) { + s[j] = styler[i + j]; + j++; + } + s[j] = '\0'; + + if (strcmp(s, "instr") == 0) + levelCurrent++; + if (strcmp(s, "endin") == 0) + levelCurrent--; + } + + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) + visibleChars++; + stylePrev = style; + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + + +static const char * const csoundWordListDesc[] = { + "Opcodes", + "Header Statements", + "User keywords", + 0 +}; + +LexerModule lmCsound(SCLEX_CSOUND, ColouriseCsoundDoc, "csound", FoldCsoundInstruments, csoundWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexD.cxx b/sdk/wxscintilla/src/scintilla/src/LexD.cxx new file mode 100644 index 0000000..4c4bcb3 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexD.cxx @@ -0,0 +1,399 @@ +/** @file LexD.cxx + ** Lexer for D. + ** + ** Copyright (c) 2006 by Waldemar Augustyn + **/ +// Copyright 1998-2005 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +/* Nested comments require keeping the value of the nesting level for every + position in the document. But since scintilla always styles line by line, + we only need to store one value per line. The non-negative number indicates + nesting level at the end of the line. +*/ + +// Underscore, letter, digit and universal alphas from C99 Appendix D. + +static bool IsWordStart(int ch) { + return (isascii(ch) && (isalpha(ch) || ch == '_')) || !isascii(ch); +} + +static bool IsWord(int ch) { + return (isascii(ch) && (isalnum(ch) || ch == '_')) || !isascii(ch); +} + +static bool IsDoxygen(int ch) { + if (isascii(ch) && islower(ch)) + return true; + if (ch == '$' || ch == '@' || ch == '\\' || + ch == '&' || ch == '#' || ch == '<' || ch == '>' || + ch == '{' || ch == '}' || ch == '[' || ch == ']') + return true; + return false; +} + +static bool IsStringSuffix(int ch) { + return ch == 'c' || ch == 'w' || ch == 'd'; +} + + +static void ColouriseDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler, bool caseSensitive) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; //doxygen + WordList &keywords4 = *keywordlists[3]; + WordList &keywords5 = *keywordlists[4]; + WordList &keywords6 = *keywordlists[5]; + WordList &keywords7 = *keywordlists[6]; + + int styleBeforeDCKeyword = SCE_D_DEFAULT; + + StyleContext sc(startPos, length, initStyle, styler); + + int curLine = styler.GetLine(startPos); + int curNcLevel = curLine > 0? styler.GetLineState(curLine-1): 0; + bool numFloat = false; // Float literals have '+' and '-' signs + bool numHex = false; + + for (; sc.More(); sc.Forward()) { + + if (sc.atLineStart) { + curLine = styler.GetLine(sc.currentPos); + styler.SetLineState(curLine, curNcLevel); + } + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_D_OPERATOR: + sc.SetState(SCE_D_DEFAULT); + break; + case SCE_D_NUMBER: + // We accept almost anything because of hex. and number suffixes + if (isascii(sc.ch) && (isalnum(sc.ch) || sc.ch == '_')) { + continue; + } else if (sc.ch == '.' && sc.chNext != '.' && !numFloat) { + // Don't parse 0..2 as number. + numFloat=true; + continue; + } else if ( ( sc.ch == '-' || sc.ch == '+' ) && ( /*sign and*/ + ( !numHex && ( sc.chPrev == 'e' || sc.chPrev == 'E' ) ) || /*decimal or*/ + ( sc.chPrev == 'p' || sc.chPrev == 'P' ) ) ) { /*hex*/ + // Parse exponent sign in float literals: 2e+10 0x2e+10 + continue; + } else { + sc.SetState(SCE_D_DEFAULT); + } + break; + case SCE_D_IDENTIFIER: + if (!IsWord(sc.ch)) { + char s[1000]; + if (caseSensitive) { + sc.GetCurrent(s, sizeof(s)); + } else { + sc.GetCurrentLowered(s, sizeof(s)); + } + if (keywords.InList(s)) { + sc.ChangeState(SCE_D_WORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_D_WORD2); + } else if (keywords4.InList(s)) { + sc.ChangeState(SCE_D_TYPEDEF); + } else if (keywords5.InList(s)) { + sc.ChangeState(SCE_D_WORD5); + } else if (keywords6.InList(s)) { + sc.ChangeState(SCE_D_WORD6); + } else if (keywords7.InList(s)) { + sc.ChangeState(SCE_D_WORD7); + } + sc.SetState(SCE_D_DEFAULT); + } + break; + case SCE_D_COMMENT: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_D_DEFAULT); + } + break; + case SCE_D_COMMENTDOC: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_D_DEFAULT); + } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support + // Verify that we have the conditions to mark a comment-doc-keyword + if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) { + styleBeforeDCKeyword = SCE_D_COMMENTDOC; + sc.SetState(SCE_D_COMMENTDOCKEYWORD); + } + } + break; + case SCE_D_COMMENTLINE: + if (sc.atLineStart) { + sc.SetState(SCE_D_DEFAULT); + } + break; + case SCE_D_COMMENTLINEDOC: + if (sc.atLineStart) { + sc.SetState(SCE_D_DEFAULT); + } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support + // Verify that we have the conditions to mark a comment-doc-keyword + if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) { + styleBeforeDCKeyword = SCE_D_COMMENTLINEDOC; + sc.SetState(SCE_D_COMMENTDOCKEYWORD); + } + } + break; + case SCE_D_COMMENTDOCKEYWORD: + if ((styleBeforeDCKeyword == SCE_D_COMMENTDOC) && sc.Match('*', '/')) { + sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR); + sc.Forward(); + sc.ForwardSetState(SCE_D_DEFAULT); + } else if (!IsDoxygen(sc.ch)) { + char s[100]; + if (caseSensitive) { + sc.GetCurrent(s, sizeof(s)); + } else { + sc.GetCurrentLowered(s, sizeof(s)); + } + if (!IsASpace(sc.ch) || !keywords3.InList(s + 1)) { + sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR); + } + sc.SetState(styleBeforeDCKeyword); + } + break; + case SCE_D_COMMENTNESTED: + if (sc.Match('+', '/')) { + if (curNcLevel > 0) + curNcLevel -= 1; + curLine = styler.GetLine(sc.currentPos); + styler.SetLineState(curLine, curNcLevel); + sc.Forward(); + if (curNcLevel == 0) { + sc.ForwardSetState(SCE_D_DEFAULT); + } + } else if (sc.Match('/','+')) { + curNcLevel += 1; + curLine = styler.GetLine(sc.currentPos); + styler.SetLineState(curLine, curNcLevel); + sc.Forward(); + } + break; + case SCE_D_STRING: + if (sc.ch == '\\') { + if (sc.chNext == '"' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '"') { + if(IsStringSuffix(sc.chNext)) + sc.Forward(); + sc.ForwardSetState(SCE_D_DEFAULT); + } + break; + case SCE_D_CHARACTER: + if (sc.atLineEnd) { + sc.ChangeState(SCE_D_STRINGEOL); + } else if (sc.ch == '\\') { + if (sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\'') { + // Char has no suffixes + sc.ForwardSetState(SCE_D_DEFAULT); + } + break; + case SCE_D_STRINGEOL: + if (sc.atLineStart) { + sc.SetState(SCE_D_DEFAULT); + } + break; + case SCE_D_STRINGB: + if (sc.ch == '`') { + if(IsStringSuffix(sc.chNext)) + sc.Forward(); + sc.ForwardSetState(SCE_D_DEFAULT); + } + break; + case SCE_D_STRINGR: + if (sc.ch == '"') { + if(IsStringSuffix(sc.chNext)) + sc.Forward(); + sc.ForwardSetState(SCE_D_DEFAULT); + } + break; + } + + // Determine if a new state should be entered. + if (sc.state == SCE_D_DEFAULT) { + if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_D_NUMBER); + numFloat = sc.ch == '.'; + // Remember hex literal + numHex = sc.ch == '0' && ( sc.chNext == 'x' || sc.chNext == 'X' ); + } else if ( (sc.ch == 'r' || sc.ch == 'x' || sc.ch == 'q') + && sc.chNext == '"' ) { + // Limited support for hex and delimited strings: parse as r"" + sc.SetState(SCE_D_STRINGR); + sc.Forward(); + } else if (IsWordStart(sc.ch) || sc.ch == '$') { + sc.SetState(SCE_D_IDENTIFIER); + } else if (sc.Match('/','+')) { + curNcLevel += 1; + curLine = styler.GetLine(sc.currentPos); + styler.SetLineState(curLine, curNcLevel); + sc.SetState(SCE_D_COMMENTNESTED); + sc.Forward(); + } else if (sc.Match('/', '*')) { + if (sc.Match("/**") || sc.Match("/*!")) { // Support of Qt/Doxygen doc. style + sc.SetState(SCE_D_COMMENTDOC); + } else { + sc.SetState(SCE_D_COMMENT); + } + sc.Forward(); // Eat the * so it isn't used for the end of the comment + } else if (sc.Match('/', '/')) { + if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!")) + // Support of Qt/Doxygen doc. style + sc.SetState(SCE_D_COMMENTLINEDOC); + else + sc.SetState(SCE_D_COMMENTLINE); + } else if (sc.ch == '"') { + sc.SetState(SCE_D_STRING); + } else if (sc.ch == '\'') { + sc.SetState(SCE_D_CHARACTER); + } else if (sc.ch == '`') { + sc.SetState(SCE_D_STRINGB); + } else if (isoperator(static_cast(sc.ch))) { + sc.SetState(SCE_D_OPERATOR); + if (sc.ch == '.' && sc.chNext == '.') sc.Forward(); // Range operator + } + } + } + sc.Complete(); +} + +static bool IsStreamCommentStyle(int style) { + return style == SCE_D_COMMENT || + style == SCE_D_COMMENTDOC || + style == SCE_D_COMMENTDOCKEYWORD || + style == SCE_D_COMMENTDOCKEYWORDERROR; +} + +// Store both the current line's fold level and the next lines in the +// level store to make it easy to pick up with each increment +// and to make it possible to fiddle the current level for "} else {". +static void FoldDoc(unsigned int startPos, int length, int initStyle, Accessor &styler) { + bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + + // property lexer.d.fold.at.else + // This option enables D folding on a "} else {" line of an if statement. + bool foldAtElse = styler.GetPropertyInt("lexer.d.fold.at.else", + styler.GetPropertyInt("fold.at.else", 0)) != 0; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelCurrent = SC_FOLDLEVELBASE; + if (lineCurrent > 0) + levelCurrent = styler.LevelAt(lineCurrent-1) >> 16; + int levelMinCurrent = levelCurrent; + int levelNext = levelCurrent; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if (foldComment && IsStreamCommentStyle(style)) { + if (!IsStreamCommentStyle(stylePrev)) { + levelNext++; + } else if (!IsStreamCommentStyle(styleNext) && !atEOL) { + // Comments don't end at end of line and the next character may be unstyled. + levelNext--; + } + } + if (style == SCE_D_OPERATOR) { + if (ch == '{') { + // Measure the minimum before a '{' to allow + // folding on "} else {" + if (levelMinCurrent > levelNext) { + levelMinCurrent = levelNext; + } + levelNext++; + } else if (ch == '}') { + levelNext--; + } + } + if (atEOL) { + if (foldComment) { // Handle nested comments + int nc; + nc = styler.GetLineState(lineCurrent); + nc -= lineCurrent>0? styler.GetLineState(lineCurrent-1): 0; + levelNext += nc; + } + int levelUse = levelCurrent; + if (foldAtElse) { + levelUse = levelMinCurrent; + } + int lev = levelUse | levelNext << 16; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if (levelUse < levelNext) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelCurrent = levelNext; + levelMinCurrent = levelCurrent; + visibleChars = 0; + } + if (!IsASpace(ch)) + visibleChars++; + } +} + +static void FoldDDoc(unsigned int startPos, int length, int initStyle, + WordList *[], Accessor &styler) { + FoldDoc(startPos, length, initStyle, styler); +} + +static const char * const dWordLists[] = { + "Primary keywords and identifiers", + "Secondary keywords and identifiers", + "Documentation comment keywords", + "Type definitions and aliases", + "Keywords 5", + "Keywords 6", + "Keywords 7", + 0, + }; + +static void ColouriseDDoc(unsigned int startPos, int length, + int initStyle, WordList *keywordlists[], Accessor &styler) { + ColouriseDoc(startPos, length, initStyle, keywordlists, styler, true); +} + +LexerModule lmD(SCLEX_D, ColouriseDDoc, "d", FoldDDoc, dWordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexEScript.cxx b/sdk/wxscintilla/src/scintilla/src/LexEScript.cxx new file mode 100644 index 0000000..295aaec --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexEScript.cxx @@ -0,0 +1,273 @@ +// Scintilla source code edit control +/** @file LexESCRIPT.cxx + ** Lexer for ESCRIPT + **/ +// Copyright 2003 by Patrizio Bekerle (patrizio@bekerle.com) + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_'); +} + +static inline bool IsAWordStart(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_'); +} + + + +static void ColouriseESCRIPTDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + + // Do not leak onto next line + /*if (initStyle == SCE_ESCRIPT_STRINGEOL) + initStyle = SCE_ESCRIPT_DEFAULT;*/ + + StyleContext sc(startPos, length, initStyle, styler); + + bool caseSensitive = styler.GetPropertyInt("escript.case.sensitive", 0) != 0; + + for (; sc.More(); sc.Forward()) { + + /*if (sc.atLineStart && (sc.state == SCE_ESCRIPT_STRING)) { + // Prevent SCE_ESCRIPT_STRINGEOL from leaking back to previous line + sc.SetState(SCE_ESCRIPT_STRING); + }*/ + + // Handle line continuation generically. + if (sc.ch == '\\') { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + continue; + } + } + + // Determine if the current state should terminate. + if (sc.state == SCE_ESCRIPT_OPERATOR || sc.state == SCE_ESCRIPT_BRACE) { + sc.SetState(SCE_ESCRIPT_DEFAULT); + } else if (sc.state == SCE_ESCRIPT_NUMBER) { + if (!IsADigit(sc.ch) || sc.ch != '.') { + sc.SetState(SCE_ESCRIPT_DEFAULT); + } + } else if (sc.state == SCE_ESCRIPT_IDENTIFIER) { + if (!IsAWordChar(sc.ch) || (sc.ch == '.')) { + char s[100]; + if (caseSensitive) { + sc.GetCurrent(s, sizeof(s)); + } else { + sc.GetCurrentLowered(s, sizeof(s)); + } + +// sc.GetCurrentLowered(s, sizeof(s)); + + if (keywords.InList(s)) { + sc.ChangeState(SCE_ESCRIPT_WORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_ESCRIPT_WORD2); + } else if (keywords3.InList(s)) { + sc.ChangeState(SCE_ESCRIPT_WORD3); + // sc.state = SCE_ESCRIPT_IDENTIFIER; + } + sc.SetState(SCE_ESCRIPT_DEFAULT); + } + } else if (sc.state == SCE_ESCRIPT_COMMENT) { + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_ESCRIPT_DEFAULT); + } + } else if (sc.state == SCE_ESCRIPT_COMMENTDOC) { + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(SCE_ESCRIPT_DEFAULT); + } + } else if (sc.state == SCE_ESCRIPT_COMMENTLINE) { + if (sc.atLineEnd) { + sc.SetState(SCE_ESCRIPT_DEFAULT); + } + } else if (sc.state == SCE_ESCRIPT_STRING) { + if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\"') { + sc.ForwardSetState(SCE_ESCRIPT_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_ESCRIPT_DEFAULT) { + if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_ESCRIPT_NUMBER); + } else if (IsAWordStart(sc.ch) || (sc.ch == '#')) { + sc.SetState(SCE_ESCRIPT_IDENTIFIER); + } else if (sc.Match('/', '*')) { + sc.SetState(SCE_ESCRIPT_COMMENT); + sc.Forward(); // Eat the * so it isn't used for the end of the comment + } else if (sc.Match('/', '/')) { + sc.SetState(SCE_ESCRIPT_COMMENTLINE); + } else if (sc.ch == '\"') { + sc.SetState(SCE_ESCRIPT_STRING); + //} else if (isoperator(static_cast(sc.ch))) { + } else if (sc.ch == '+' || sc.ch == '-' || sc.ch == '*' || sc.ch == '/' || sc.ch == '=' || sc.ch == '<' || sc.ch == '>' || sc.ch == '&' || sc.ch == '|' || sc.ch == '!' || sc.ch == '?' || sc.ch == ':') { + sc.SetState(SCE_ESCRIPT_OPERATOR); + } else if (sc.ch == '{' || sc.ch == '}') { + sc.SetState(SCE_ESCRIPT_BRACE); + } + } + + } + sc.Complete(); +} + + +static int classifyFoldPointESCRIPT(const char* s, const char* prevWord) { + int lev = 0; + if (strcmp(prevWord, "end") == 0) return lev; + if ((strcmp(prevWord, "else") == 0 && strcmp(s, "if") == 0) || strcmp(s, "elseif") == 0) + return -1; + + if (strcmp(s, "for") == 0 || strcmp(s, "foreach") == 0 + || strcmp(s, "program") == 0 || strcmp(s, "function") == 0 + || strcmp(s, "while") == 0 || strcmp(s, "case") == 0 + || strcmp(s, "if") == 0 ) { + lev = 1; + } else if ( strcmp(s, "endfor") == 0 || strcmp(s, "endforeach") == 0 + || strcmp(s, "endprogram") == 0 || strcmp(s, "endfunction") == 0 + || strcmp(s, "endwhile") == 0 || strcmp(s, "endcase") == 0 + || strcmp(s, "endif") == 0 ) { + lev = -1; + } + + return lev; +} + + +static bool IsStreamCommentStyle(int style) { + return style == SCE_ESCRIPT_COMMENT || + style == SCE_ESCRIPT_COMMENTDOC || + style == SCE_ESCRIPT_COMMENTLINE; +} + +static void FoldESCRIPTDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler) { + //~ bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + // Do not know how to fold the comment at the moment. + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + bool foldComment = true; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + + int lastStart = 0; + char prevWord[32] = ""; + + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + + + if (foldComment && IsStreamCommentStyle(style)) { + if (!IsStreamCommentStyle(stylePrev)) { + levelCurrent++; + } else if (!IsStreamCommentStyle(styleNext) && !atEOL) { + // Comments don't end at end of line and the next character may be unstyled. + levelCurrent--; + } + } + + if (foldComment && (style == SCE_ESCRIPT_COMMENTLINE)) { + if ((ch == '/') && (chNext == '/')) { + char chNext2 = styler.SafeGetCharAt(i + 2); + if (chNext2 == '{') { + levelCurrent++; + } else if (chNext2 == '}') { + levelCurrent--; + } + } + } + + if (stylePrev == SCE_ESCRIPT_DEFAULT && style == SCE_ESCRIPT_WORD3) + { + // Store last word start point. + lastStart = i; + } + + if (style == SCE_ESCRIPT_WORD3) { + if(iswordchar(ch) && !iswordchar(chNext)) { + char s[32]; + unsigned int j; + for(j = 0; ( j < 31 ) && ( j < i-lastStart+1 ); j++) { + s[j] = static_cast(tolower(styler[lastStart + j])); + } + s[j] = '\0'; + levelCurrent += classifyFoldPointESCRIPT(s, prevWord); + strcpy(prevWord, s); + } + } + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + strcpy(prevWord, ""); + } + + if (!isspacechar(ch)) + visibleChars++; + } + + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + + + +static const char * const ESCRIPTWordLists[] = { + "Primary keywords and identifiers", + "Intrinsic functions", + "Extended and user defined functions", + 0, +}; + +LexerModule lmESCRIPT(SCLEX_ESCRIPT, ColouriseESCRIPTDoc, "escript", FoldESCRIPTDoc, ESCRIPTWordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexEiffel.cxx b/sdk/wxscintilla/src/scintilla/src/LexEiffel.cxx new file mode 100644 index 0000000..03dea5e --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexEiffel.cxx @@ -0,0 +1,238 @@ +// Scintilla source code edit control +/** @file LexEiffel.cxx + ** Lexer for Eiffel. + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool isEiffelOperator(unsigned int ch) { + // '.' left out as it is used to make up numbers + return ch == '*' || ch == '/' || ch == '\\' || ch == '-' || ch == '+' || + ch == '(' || ch == ')' || ch == '=' || + ch == '{' || ch == '}' || ch == '~' || + ch == '[' || ch == ']' || ch == ';' || + ch == '<' || ch == '>' || ch == ',' || + ch == '.' || ch == '^' || ch == '%' || ch == ':' || + ch == '!' || ch == '@' || ch == '?'; +} + +static inline bool IsAWordChar(unsigned int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_'); +} + +static inline bool IsAWordStart(unsigned int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_'); +} + +static void ColouriseEiffelDoc(unsigned int startPos, + int length, + int initStyle, + WordList *keywordlists[], + Accessor &styler) { + + WordList &keywords = *keywordlists[0]; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + if (sc.state == SCE_EIFFEL_STRINGEOL) { + if (sc.ch != '\r' && sc.ch != '\n') { + sc.SetState(SCE_EIFFEL_DEFAULT); + } + } else if (sc.state == SCE_EIFFEL_OPERATOR) { + sc.SetState(SCE_EIFFEL_DEFAULT); + } else if (sc.state == SCE_EIFFEL_WORD) { + if (!IsAWordChar(sc.ch)) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + if (!keywords.InList(s)) { + sc.ChangeState(SCE_EIFFEL_IDENTIFIER); + } + sc.SetState(SCE_EIFFEL_DEFAULT); + } + } else if (sc.state == SCE_EIFFEL_NUMBER) { + if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_EIFFEL_DEFAULT); + } + } else if (sc.state == SCE_EIFFEL_COMMENTLINE) { + if (sc.ch == '\r' || sc.ch == '\n') { + sc.SetState(SCE_EIFFEL_DEFAULT); + } + } else if (sc.state == SCE_EIFFEL_STRING) { + if (sc.ch == '%') { + sc.Forward(); + } else if (sc.ch == '\"') { + sc.Forward(); + sc.SetState(SCE_EIFFEL_DEFAULT); + } + } else if (sc.state == SCE_EIFFEL_CHARACTER) { + if (sc.ch == '\r' || sc.ch == '\n') { + sc.SetState(SCE_EIFFEL_STRINGEOL); + } else if (sc.ch == '%') { + sc.Forward(); + } else if (sc.ch == '\'') { + sc.Forward(); + sc.SetState(SCE_EIFFEL_DEFAULT); + } + } + + if (sc.state == SCE_EIFFEL_DEFAULT) { + if (sc.ch == '-' && sc.chNext == '-') { + sc.SetState(SCE_EIFFEL_COMMENTLINE); + } else if (sc.ch == '\"') { + sc.SetState(SCE_EIFFEL_STRING); + } else if (sc.ch == '\'') { + sc.SetState(SCE_EIFFEL_CHARACTER); + } else if (IsADigit(sc.ch) || (sc.ch == '.')) { + sc.SetState(SCE_EIFFEL_NUMBER); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_EIFFEL_WORD); + } else if (isEiffelOperator(sc.ch)) { + sc.SetState(SCE_EIFFEL_OPERATOR); + } + } + } + sc.Complete(); +} + +static bool IsEiffelComment(Accessor &styler, int pos, int len) { + return len>1 && styler[pos]=='-' && styler[pos+1]=='-'; +} + +static void FoldEiffelDocIndent(unsigned int startPos, int length, int, + WordList *[], Accessor &styler) { + int lengthDoc = startPos + length; + + // Backtrack to previous line in case need to fix its fold status + int lineCurrent = styler.GetLine(startPos); + if (startPos > 0) { + if (lineCurrent > 0) { + lineCurrent--; + startPos = styler.LineStart(lineCurrent); + } + } + int spaceFlags = 0; + int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsEiffelComment); + char chNext = styler[startPos]; + for (int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == lengthDoc)) { + int lev = indentCurrent; + int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags, IsEiffelComment); + if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) { + // Only non whitespace lines can be headers + if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) { + lev |= SC_FOLDLEVELHEADERFLAG; + } else if (indentNext & SC_FOLDLEVELWHITEFLAG) { + // Line after is blank so check the next - maybe should continue further? + int spaceFlags2 = 0; + int indentNext2 = styler.IndentAmount(lineCurrent + 2, &spaceFlags2, IsEiffelComment); + if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext2 & SC_FOLDLEVELNUMBERMASK)) { + lev |= SC_FOLDLEVELHEADERFLAG; + } + } + } + indentCurrent = indentNext; + styler.SetLevel(lineCurrent, lev); + lineCurrent++; + } + } +} + +static void FoldEiffelDocKeyWords(unsigned int startPos, int length, int /* initStyle */, WordList *[], + Accessor &styler) { + unsigned int lengthDoc = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + int stylePrev = 0; + int styleNext = styler.StyleAt(startPos); + // lastDeferred should be determined by looking back to last keyword in case + // the "deferred" is on a line before "class" + bool lastDeferred = false; + for (unsigned int i = startPos; i < lengthDoc; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + if ((stylePrev != SCE_EIFFEL_WORD) && (style == SCE_EIFFEL_WORD)) { + char s[20]; + unsigned int j = 0; + while ((j < (sizeof(s) - 1)) && (iswordchar(styler[i + j]))) { + s[j] = styler[i + j]; + j++; + } + s[j] = '\0'; + + if ( + (strcmp(s, "check") == 0) || + (strcmp(s, "debug") == 0) || + (strcmp(s, "deferred") == 0) || + (strcmp(s, "do") == 0) || + (strcmp(s, "from") == 0) || + (strcmp(s, "if") == 0) || + (strcmp(s, "inspect") == 0) || + (strcmp(s, "once") == 0) + ) + levelCurrent++; + if (!lastDeferred && (strcmp(s, "class") == 0)) + levelCurrent++; + if (strcmp(s, "end") == 0) + levelCurrent--; + lastDeferred = strcmp(s, "deferred") == 0; + } + + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + if (!isspacechar(ch)) + visibleChars++; + stylePrev = style; + } + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +static const char * const eiffelWordListDesc[] = { + "Keywords", + 0 +}; + +LexerModule lmEiffel(SCLEX_EIFFEL, ColouriseEiffelDoc, "eiffel", FoldEiffelDocIndent, eiffelWordListDesc); +LexerModule lmEiffelkw(SCLEX_EIFFELKW, ColouriseEiffelDoc, "eiffelkw", FoldEiffelDocKeyWords, eiffelWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexErlang.cxx b/sdk/wxscintilla/src/scintilla/src/LexErlang.cxx new file mode 100644 index 0000000..45577bd --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexErlang.cxx @@ -0,0 +1,619 @@ +// Scintilla source code edit control +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. +/** @file LexErlang.cxx + ** Lexer for Erlang. + ** Enhanced by Etienne 'Lenain' Girondel (lenaing@gmail.com) + ** Originally wrote by Peter-Henry Mander, + ** based on Matlab lexer by Jos Fonseca. + **/ + +#include +#include +#include +#include +#include + +#include "Platform.h" +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static int is_radix(int radix, int ch) { + int digit; + + if (36 < radix || 2 > radix) + return 0; + + if (isdigit(ch)) { + digit = ch - '0'; + } else if (isalnum(ch)) { + digit = toupper(ch) - 'A' + 10; + } else { + return 0; + } + + return (digit < radix); +} + +typedef enum { + STATE_NULL, + COMMENT, + COMMENT_FUNCTION, + COMMENT_MODULE, + COMMENT_DOC, + COMMENT_DOC_MACRO, + ATOM_UNQUOTED, + ATOM_QUOTED, + NODE_NAME_UNQUOTED, + NODE_NAME_QUOTED, + MACRO_START, + MACRO_UNQUOTED, + MACRO_QUOTED, + RECORD_START, + RECORD_UNQUOTED, + RECORD_QUOTED, + NUMERAL_START, + NUMERAL_BASE_VALUE, + NUMERAL_FLOAT, + NUMERAL_EXPONENT, + PREPROCESSOR +} atom_parse_state_t; + +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (ch != ' ') && (isalnum(ch) || ch == '_'); +} + +static void ColouriseErlangDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) { + + StyleContext sc(startPos, length, initStyle, styler); + WordList &reservedWords = *keywordlists[0]; + WordList &erlangBIFs = *keywordlists[1]; + WordList &erlangPreproc = *keywordlists[2]; + WordList &erlangModulesAtt = *keywordlists[3]; + WordList &erlangDoc = *keywordlists[4]; + WordList &erlangDocMacro = *keywordlists[5]; + int radix_digits = 0; + int exponent_digits = 0; + atom_parse_state_t parse_state = STATE_NULL; + atom_parse_state_t old_parse_state = STATE_NULL; + bool to_late_to_comment = false; + char cur[100]; + int old_style = SCE_ERLANG_DEFAULT; + + styler.StartAt(startPos); + + for (; sc.More(); sc.Forward()) { + int style = SCE_ERLANG_DEFAULT; + if (STATE_NULL != parse_state) { + + switch (parse_state) { + + case STATE_NULL : sc.SetState(SCE_ERLANG_DEFAULT); break; + + /* COMMENTS ------------------------------------------------------*/ + case COMMENT : { + if (sc.ch != '%') { + to_late_to_comment = true; + } else if (!to_late_to_comment && sc.ch == '%') { + // Switch to comment level 2 (Function) + sc.ChangeState(SCE_ERLANG_COMMENT_FUNCTION); + old_style = SCE_ERLANG_COMMENT_FUNCTION; + parse_state = COMMENT_FUNCTION; + sc.Forward(); + } + } + // V--- Falling through! + case COMMENT_FUNCTION : { + if (sc.ch != '%') { + to_late_to_comment = true; + } else if (!to_late_to_comment && sc.ch == '%') { + // Switch to comment level 3 (Module) + sc.ChangeState(SCE_ERLANG_COMMENT_MODULE); + old_style = SCE_ERLANG_COMMENT_MODULE; + parse_state = COMMENT_MODULE; + sc.Forward(); + } + } + // V--- Falling through! + case COMMENT_MODULE : { + if (parse_state != COMMENT) { + // Search for comment documentation + if (sc.chNext == '@') { + old_parse_state = parse_state; + parse_state = ('{' == sc.ch) + ? COMMENT_DOC_MACRO + : COMMENT_DOC; + sc.ForwardSetState(sc.state); + } + } + + // All comments types fall here. + if (sc.atLineEnd) { + to_late_to_comment = false; + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + case COMMENT_DOC : + // V--- Falling through! + case COMMENT_DOC_MACRO : { + + if (!isalnum(sc.ch)) { + // Try to match documentation comment + sc.GetCurrent(cur, sizeof(cur)); + + if (parse_state == COMMENT_DOC_MACRO + && erlangDocMacro.InList(cur)) { + sc.ChangeState(SCE_ERLANG_COMMENT_DOC_MACRO); + while (sc.ch != '}' && !sc.atLineEnd) + sc.Forward(); + } else if (erlangDoc.InList(cur)) { + sc.ChangeState(SCE_ERLANG_COMMENT_DOC); + } else { + sc.ChangeState(old_style); + } + + // Switch back to old state + sc.SetState(old_style); + parse_state = old_parse_state; + } + + if (sc.atLineEnd) { + to_late_to_comment = false; + sc.ChangeState(old_style); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* -------------------------------------------------------------- */ + /* Atoms ---------------------------------------------------------*/ + case ATOM_UNQUOTED : { + if ('@' == sc.ch){ + parse_state = NODE_NAME_UNQUOTED; + } else if (sc.ch == ':') { + // Searching for module name + if (sc.chNext == ' ') { + // error + sc.ChangeState(SCE_ERLANG_UNKNOWN); + parse_state = STATE_NULL; + } else { + sc.Forward(); + if (isalnum(sc.ch)) { + sc.GetCurrent(cur, sizeof(cur)); + sc.ChangeState(SCE_ERLANG_MODULES); + sc.SetState(SCE_ERLANG_MODULES); + } + } + } else if (!IsAWordChar(sc.ch)) { + + sc.GetCurrent(cur, sizeof(cur)); + if (reservedWords.InList(cur)) { + style = SCE_ERLANG_KEYWORD; + } else if (erlangBIFs.InList(cur) + && strcmp(cur,"erlang:")){ + style = SCE_ERLANG_BIFS; + } else if (sc.ch == '(' || '/' == sc.ch){ + style = SCE_ERLANG_FUNCTION_NAME; + } else { + style = SCE_ERLANG_ATOM; + } + + sc.ChangeState(style); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + + } break; + + case ATOM_QUOTED : { + if ( '@' == sc.ch ){ + parse_state = NODE_NAME_QUOTED; + } else if ('\'' == sc.ch && '\\' != sc.chPrev) { + sc.ChangeState(SCE_ERLANG_ATOM); + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* -------------------------------------------------------------- */ + /* Node names ----------------------------------------------------*/ + case NODE_NAME_UNQUOTED : { + if ('@' == sc.ch) { + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } else if (!IsAWordChar(sc.ch)) { + sc.ChangeState(SCE_ERLANG_NODE_NAME); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + case NODE_NAME_QUOTED : { + if ('@' == sc.ch) { + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } else if ('\'' == sc.ch && '\\' != sc.chPrev) { + sc.ChangeState(SCE_ERLANG_NODE_NAME_QUOTED); + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* -------------------------------------------------------------- */ + /* Records -------------------------------------------------------*/ + case RECORD_START : { + if ('\'' == sc.ch) { + parse_state = RECORD_QUOTED; + } else if (isalpha(sc.ch) && islower(sc.ch)) { + parse_state = RECORD_UNQUOTED; + } else { // error + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + case RECORD_UNQUOTED : { + if (!IsAWordChar(sc.ch)) { + sc.ChangeState(SCE_ERLANG_RECORD); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + case RECORD_QUOTED : { + if ('\'' == sc.ch && '\\' != sc.chPrev) { + sc.ChangeState(SCE_ERLANG_RECORD_QUOTED); + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* -------------------------------------------------------------- */ + /* Macros --------------------------------------------------------*/ + case MACRO_START : { + if ('\'' == sc.ch) { + parse_state = MACRO_QUOTED; + } else if (isalpha(sc.ch)) { + parse_state = MACRO_UNQUOTED; + } else { // error + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + case MACRO_UNQUOTED : { + if (!IsAWordChar(sc.ch)) { + sc.ChangeState(SCE_ERLANG_MACRO); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + case MACRO_QUOTED : { + if ('\'' == sc.ch && '\\' != sc.chPrev) { + sc.ChangeState(SCE_ERLANG_MACRO_QUOTED); + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* -------------------------------------------------------------- */ + /* Numerics ------------------------------------------------------*/ + /* Simple integer */ + case NUMERAL_START : { + if (isdigit(sc.ch)) { + radix_digits *= 10; + radix_digits += sc.ch - '0'; // Assuming ASCII here! + } else if ('#' == sc.ch) { + if (2 > radix_digits || 36 < radix_digits) { + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } else { + parse_state = NUMERAL_BASE_VALUE; + } + } else if ('.' == sc.ch && isdigit(sc.chNext)) { + radix_digits = 0; + parse_state = NUMERAL_FLOAT; + } else if ('e' == sc.ch || 'E' == sc.ch) { + exponent_digits = 0; + parse_state = NUMERAL_EXPONENT; + } else { + radix_digits = 0; + sc.ChangeState(SCE_ERLANG_NUMBER); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* Integer in other base than 10 (x#yyy) */ + case NUMERAL_BASE_VALUE : { + if (!is_radix(radix_digits,sc.ch)) { + radix_digits = 0; + + if (!isalnum(sc.ch)) + sc.ChangeState(SCE_ERLANG_NUMBER); + + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* Float (x.yyy) */ + case NUMERAL_FLOAT : { + if ('e' == sc.ch || 'E' == sc.ch) { + exponent_digits = 0; + parse_state = NUMERAL_EXPONENT; + } else if (!isdigit(sc.ch)) { + sc.ChangeState(SCE_ERLANG_NUMBER); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + /* Exponent, either integer or float (xEyy, x.yyEzzz) */ + case NUMERAL_EXPONENT : { + if (('-' == sc.ch || '+' == sc.ch) + && (isdigit(sc.chNext))) { + sc.Forward(); + } else if (!isdigit(sc.ch)) { + if (0 < exponent_digits) + sc.ChangeState(SCE_ERLANG_NUMBER); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } else { + ++exponent_digits; + } + } break; + + /* -------------------------------------------------------------- */ + /* Preprocessor --------------------------------------------------*/ + case PREPROCESSOR : { + if (!IsAWordChar(sc.ch)) { + + sc.GetCurrent(cur, sizeof(cur)); + if (erlangPreproc.InList(cur)) { + style = SCE_ERLANG_PREPROC; + } else if (erlangModulesAtt.InList(cur)) { + style = SCE_ERLANG_MODULES_ATT; + } + + sc.ChangeState(style); + sc.SetState(SCE_ERLANG_DEFAULT); + parse_state = STATE_NULL; + } + } break; + + } + + } /* End of : STATE_NULL != parse_state */ + else + { + switch (sc.state) { + case SCE_ERLANG_VARIABLE : { + if (!IsAWordChar(sc.ch)) + sc.SetState(SCE_ERLANG_DEFAULT); + } break; + case SCE_ERLANG_STRING : { + if (sc.ch == '\"' && sc.chPrev != '\\') + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + } break; + case SCE_ERLANG_COMMENT : { + if (sc.atLineEnd) + sc.SetState(SCE_ERLANG_DEFAULT); + } break; + case SCE_ERLANG_CHARACTER : { + if (sc.chPrev == '\\') { + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + } else if (sc.ch != '\\') { + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + } + } break; + case SCE_ERLANG_OPERATOR : { + if (sc.chPrev == '.') { + if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' + || sc.ch == '^') { + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + } else if (sc.ch == '\'') { + sc.ForwardSetState(SCE_ERLANG_DEFAULT); + } else { + sc.SetState(SCE_ERLANG_DEFAULT); + } + } else { + sc.SetState(SCE_ERLANG_DEFAULT); + } + } break; + } + } + + if (sc.state == SCE_ERLANG_DEFAULT) { + bool no_new_state = false; + + switch (sc.ch) { + case '\"' : sc.SetState(SCE_ERLANG_STRING); break; + case '$' : sc.SetState(SCE_ERLANG_CHARACTER); break; + case '%' : { + parse_state = COMMENT; + sc.SetState(SCE_ERLANG_COMMENT); + } break; + case '#' : { + parse_state = RECORD_START; + sc.SetState(SCE_ERLANG_UNKNOWN); + } break; + case '?' : { + parse_state = MACRO_START; + sc.SetState(SCE_ERLANG_UNKNOWN); + } break; + case '\'' : { + parse_state = ATOM_QUOTED; + sc.SetState(SCE_ERLANG_UNKNOWN); + } break; + case '+' : + case '-' : { + if (IsADigit(sc.chNext)) { + parse_state = NUMERAL_START; + radix_digits = 0; + sc.SetState(SCE_ERLANG_UNKNOWN); + } else if (sc.ch != '+') { + parse_state = PREPROCESSOR; + sc.SetState(SCE_ERLANG_UNKNOWN); + } + } break; + default : no_new_state = true; + } + + if (no_new_state) { + if (isdigit(sc.ch)) { + parse_state = NUMERAL_START; + radix_digits = sc.ch - '0'; + sc.SetState(SCE_ERLANG_UNKNOWN); + } else if (isupper(sc.ch) || '_' == sc.ch) { + sc.SetState(SCE_ERLANG_VARIABLE); + } else if (isalpha(sc.ch)) { + parse_state = ATOM_UNQUOTED; + sc.SetState(SCE_ERLANG_UNKNOWN); + } else if (isoperator(static_cast(sc.ch)) + || sc.ch == '\\') { + sc.SetState(SCE_ERLANG_OPERATOR); + } + } + } + + } + sc.Complete(); +} + +static int ClassifyErlangFoldPoint( + Accessor &styler, + int styleNext, + int keyword_start +) { + int lev = 0; + if (styler.Match(keyword_start,"case") + || ( + styler.Match(keyword_start,"fun") + && (SCE_ERLANG_FUNCTION_NAME != styleNext) + ) + || styler.Match(keyword_start,"if") + || styler.Match(keyword_start,"query") + || styler.Match(keyword_start,"receive") + ) { + ++lev; + } else if (styler.Match(keyword_start,"end")) { + --lev; + } + + return lev; +} + +static void FoldErlangDoc( + unsigned int startPos, int length, int initStyle, + WordList** /*keywordlists*/, Accessor &styler +) { + unsigned int endPos = startPos + length; + int currentLine = styler.GetLine(startPos); + int lev; + int previousLevel = styler.LevelAt(currentLine) & SC_FOLDLEVELNUMBERMASK; + int currentLevel = previousLevel; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + int stylePrev; + int keyword_start = 0; + char ch; + char chNext = styler.SafeGetCharAt(startPos); + bool atEOL; + + for (unsigned int i = startPos; i < endPos; i++) { + ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + // Get styles + stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + atEOL = ((ch == '\r') && (chNext != '\n')) || (ch == '\n'); + + if (stylePrev != SCE_ERLANG_KEYWORD + && style == SCE_ERLANG_KEYWORD) { + keyword_start = i; + } + + // Fold on keywords + if (stylePrev == SCE_ERLANG_KEYWORD + && style != SCE_ERLANG_KEYWORD + && style != SCE_ERLANG_ATOM + ) { + currentLevel += ClassifyErlangFoldPoint(styler, + styleNext, + keyword_start); + } + + // Fold on comments + if (style == SCE_ERLANG_COMMENT + || style == SCE_ERLANG_COMMENT_MODULE + || style == SCE_ERLANG_COMMENT_FUNCTION) { + + if (ch == '%' && chNext == '{') { + currentLevel++; + } else if (ch == '%' && chNext == '}') { + currentLevel--; + } + } + + // Fold on braces + if (style == SCE_ERLANG_OPERATOR) { + if (ch == '{' || ch == '(' || ch == '[') { + currentLevel++; + } else if (ch == '}' || ch == ')' || ch == ']') { + currentLevel--; + } + } + + + if (atEOL) { + lev = previousLevel; + + if (currentLevel > previousLevel) + lev |= SC_FOLDLEVELHEADERFLAG; + + if (lev != styler.LevelAt(currentLine)) + styler.SetLevel(currentLine, lev); + + currentLine++; + previousLevel = currentLevel; + } + + } + + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + styler.SetLevel(currentLine, + previousLevel + | (styler.LevelAt(currentLine) & ~SC_FOLDLEVELNUMBERMASK)); +} + +static const char * const erlangWordListDesc[] = { + "Erlang Reserved words", + "Erlang BIFs", + "Erlang Preprocessor", + "Erlang Module Attributes", + "Erlang Documentation", + "Erlang Documentation Macro", + 0 +}; + +LexerModule lmErlang( + SCLEX_ERLANG, + ColouriseErlangDoc, + "erlang", + FoldErlangDoc, + erlangWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexFIF.cxx b/sdk/wxscintilla/src/scintilla/src/LexFIF.cxx new file mode 100644 index 0000000..1d2a516 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexFIF.cxx @@ -0,0 +1,130 @@ +// Scintilla source code edit control +/** @file LexFIF.cxx + ** Lexers for Find In Files output format + **/ +// Copyright 1998-2001 by Eran Ifrah +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool AtEOL(Accessor &styler, unsigned int i) +{ + return (styler[i] == '\n') || + ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n')); +} + +static void ColouriseFifDoc(unsigned int pos, int length, int /*initStyle*/, + WordList *[], Accessor &styler) +{ + styler.StartAt(pos); + styler.StartSegment(pos); + for (int firstchar = -1; length > 0; pos++, length--) { + if (firstchar == -1) { + firstchar = styler[pos]; // first char of each line + } + if (styler[pos] == ':' && firstchar == ' ') { + if (length > 1 && styler[pos+1] == ' ') { + // include the following space + pos++; + length--; + } + styler.ColourTo(pos, SCLEX_FIF_FILE_SHORT); + firstchar = ':'; // first colon only + if (length > 1 && styler[pos+1] == '[') { + firstchar = '['; + } + } else if (styler[pos] == ']' && firstchar == '['){ + if (length > 1 && styler[pos+1] == ' ') { + // include the following space + pos++; + length--; + } + styler.ColourTo(pos, SCLEX_FIF_SCOPE); + firstchar = ']'; // first ']' only + } else if (AtEOL(styler, pos)) { + switch (firstchar) { + case ' ': + case ':': + case '[': + case ']': + styler.ColourTo(pos, SCLEX_FIF_MATCH); + break; + case '=': + styler.ColourTo(pos, SCLEX_FIF_DEFAULT); + break; + case '-': + styler.ColourTo(pos, SCLEX_FIF_PROJECT); + break; + default: + styler.ColourTo(pos, SCLEX_FIF_FILE); + break; + } + firstchar = -1; + } + } +} + +static void FoldFifDoc(unsigned int pos, int length, int, + WordList*[], Accessor &styler) +{ + int curLine = styler.GetLine(pos); + int prevLevel = curLine > 0 ? styler.LevelAt(curLine-1) : SC_FOLDLEVELBASE; + + unsigned int end = pos+length; + pos = styler.LineStart(curLine); + + do { + int nextLevel; + switch (styler.StyleAt(pos)) { + case SCLEX_FIF_DEFAULT: + nextLevel = SC_FOLDLEVELBASE; + break; + case SCLEX_FIF_PROJECT: + nextLevel = (SC_FOLDLEVELBASE + 1) | SC_FOLDLEVELHEADERFLAG; + break; + case SCLEX_FIF_FILE: + nextLevel = (SC_FOLDLEVELBASE + 2) | SC_FOLDLEVELHEADERFLAG; + break; + default: + nextLevel = prevLevel & SC_FOLDLEVELHEADERFLAG ? (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1 : prevLevel; + break; + } + if ((nextLevel & SC_FOLDLEVELHEADERFLAG) && nextLevel == prevLevel) { + styler.SetLevel(curLine-1, prevLevel & ~SC_FOLDLEVELHEADERFLAG); + } + styler.SetLevel(curLine, nextLevel); + + curLine++; + prevLevel = nextLevel; + pos = styler.LineStart(curLine); + } while (pos < end); +} + +static const char * const fifWordListDesc[] = { + "Internal Commands", + "External Commands", + 0 +}; + +static const char * const emptyWordListDesc[] = { + 0 +}; + +LexerModule lmFif(SCLEX_FIF, ColouriseFifDoc, "fif", FoldFifDoc, fifWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexFlagship.cxx b/sdk/wxscintilla/src/scintilla/src/LexFlagship.cxx new file mode 100644 index 0000000..e3a8b9f --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexFlagship.cxx @@ -0,0 +1,352 @@ +// Scintilla source code edit control +/** @file LexFlagShip.cxx + ** Lexer for Harbour and FlagShip. + ** (Syntactically compatible to other xBase dialects, like Clipper, dBase, Clip, FoxPro etc.) + **/ +// Copyright 2005 by Randy Butler +// Copyright 2010 by Xavi (Harbour) +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "CharacterSet.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +// Extended to accept accented characters +static inline bool IsAWordChar(int ch) +{ + return ch >= 0x80 || + (isalnum(ch) || ch == '_'); +} + +static void ColouriseFlagShipDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler) +{ + + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + WordList &keywords4 = *keywordlists[3]; + WordList &keywords5 = *keywordlists[4]; + + // property lexer.flagship.styling.within.preprocessor + // For Harbour code, determines whether all preprocessor code is styled in the preprocessor style (0) or only from the + // initial # to the end of the command word(1, the default). It also determines how to present text, dump, and disabled code. + bool stylingWithinPreprocessor = styler.GetPropertyInt("lexer.flagship.styling.within.preprocessor", 1) != 0; + + CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\\&<>#{}[]"); + + int visibleChars = 0; + int closeStringChar = 0; + int styleBeforeDCKeyword = SCE_FS_DEFAULT; + bool bEnableCode = initStyle < SCE_FS_DISABLEDCODE; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + // Determine if the current state should terminate. + switch (sc.state) { + case SCE_FS_OPERATOR: + case SCE_FS_OPERATOR_C: + case SCE_FS_WORDOPERATOR: + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + break; + case SCE_FS_IDENTIFIER: + case SCE_FS_IDENTIFIER_C: + if (!IsAWordChar(sc.ch)) { + char s[64]; + sc.GetCurrentLowered(s, sizeof(s)); + if (keywords.InList(s)) { + sc.ChangeState(bEnableCode ? SCE_FS_KEYWORD : SCE_FS_KEYWORD_C); + } else if (keywords2.InList(s)) { + sc.ChangeState(bEnableCode ? SCE_FS_KEYWORD2 : SCE_FS_KEYWORD2_C); + } else if (bEnableCode && keywords3.InList(s)) { + sc.ChangeState(SCE_FS_KEYWORD3); + } else if (bEnableCode && keywords4.InList(s)) { + sc.ChangeState(SCE_FS_KEYWORD4); + }// Else, it is really an identifier... + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } + break; + case SCE_FS_NUMBER: + if (!IsAWordChar(sc.ch) && !(sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_FS_DEFAULT); + } + break; + case SCE_FS_NUMBER_C: + if (!IsAWordChar(sc.ch) && sc.ch != '.') { + sc.SetState(SCE_FS_DEFAULT_C); + } + break; + case SCE_FS_CONSTANT: + if (!IsAWordChar(sc.ch)) { + sc.SetState(SCE_FS_DEFAULT); + } + break; + case SCE_FS_STRING: + case SCE_FS_STRING_C: + if (sc.ch == closeStringChar) { + sc.ForwardSetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } else if (sc.atLineEnd) { + sc.ChangeState(bEnableCode ? SCE_FS_STRINGEOL : SCE_FS_STRINGEOL_C); + } + break; + case SCE_FS_STRINGEOL: + case SCE_FS_STRINGEOL_C: + if (sc.atLineStart) { + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } + break; + case SCE_FS_COMMENTDOC: + case SCE_FS_COMMENTDOC_C: + if (sc.Match('*', '/')) { + sc.Forward(); + sc.ForwardSetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support + // Verify that we have the conditions to mark a comment-doc-keyword + if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) { + styleBeforeDCKeyword = bEnableCode ? SCE_FS_COMMENTDOC : SCE_FS_COMMENTDOC_C; + sc.SetState(SCE_FS_COMMENTDOCKEYWORD); + } + } + break; + case SCE_FS_COMMENT: + case SCE_FS_COMMENTLINE: + if (sc.atLineStart) { + sc.SetState(SCE_FS_DEFAULT); + } + break; + case SCE_FS_COMMENTLINEDOC: + case SCE_FS_COMMENTLINEDOC_C: + if (sc.atLineStart) { + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support + // Verify that we have the conditions to mark a comment-doc-keyword + if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) { + styleBeforeDCKeyword = bEnableCode ? SCE_FS_COMMENTLINEDOC : SCE_FS_COMMENTLINEDOC_C; + sc.SetState(SCE_FS_COMMENTDOCKEYWORD); + } + } + break; + case SCE_FS_COMMENTDOCKEYWORD: + if ((styleBeforeDCKeyword == SCE_FS_COMMENTDOC || styleBeforeDCKeyword == SCE_FS_COMMENTDOC_C) && + sc.Match('*', '/')) { + sc.ChangeState(SCE_FS_COMMENTDOCKEYWORDERROR); + sc.Forward(); + sc.ForwardSetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } else if (!setDoxygen.Contains(sc.ch)) { + char s[64]; + sc.GetCurrentLowered(s, sizeof(s)); + if (!IsASpace(sc.ch) || !keywords5.InList(s + 1)) { + sc.ChangeState(SCE_FS_COMMENTDOCKEYWORDERROR); + } + sc.SetState(styleBeforeDCKeyword); + } + break; + case SCE_FS_PREPROCESSOR: + case SCE_FS_PREPROCESSOR_C: + if (sc.atLineEnd) { + if (!(sc.chPrev == ';' || sc.GetRelative(-2) == ';')) { + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } + } else if (stylingWithinPreprocessor) { + if (IsASpaceOrTab(sc.ch)) { + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } + } else if (sc.Match('/', '*') || sc.Match('/', '/') || sc.Match('&', '&')) { + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } + break; + case SCE_FS_DISABLEDCODE: + if (sc.ch == '#' && visibleChars == 0) { + sc.SetState(bEnableCode ? SCE_FS_PREPROCESSOR : SCE_FS_PREPROCESSOR_C); + do { // Skip whitespace between # and preprocessor word + sc.Forward(); + } while (IsASpaceOrTab(sc.ch) && sc.More()); + if (sc.MatchIgnoreCase("pragma")) { + sc.Forward(6); + do { // Skip more whitespace until keyword + sc.Forward(); + } while (IsASpaceOrTab(sc.ch) && sc.More()); + if (sc.MatchIgnoreCase("enddump") || sc.MatchIgnoreCase("__endtext")) { + bEnableCode = true; + sc.SetState(SCE_FS_DISABLEDCODE); + sc.Forward(sc.ch == '_' ? 8 : 6); + sc.ForwardSetState(SCE_FS_DEFAULT); + } else { + sc.ChangeState(SCE_FS_DISABLEDCODE); + } + } else { + sc.ChangeState(SCE_FS_DISABLEDCODE); + } + } + break; + case SCE_FS_DATE: + if (sc.ch == '}') { + sc.ForwardSetState(SCE_FS_DEFAULT); + } else if (sc.atLineEnd) { + sc.ChangeState(SCE_FS_STRINGEOL); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_FS_DEFAULT || sc.state == SCE_FS_DEFAULT_C) { + if (bEnableCode && + (sc.MatchIgnoreCase(".and.") || sc.MatchIgnoreCase(".not."))) { + sc.SetState(SCE_FS_WORDOPERATOR); + sc.Forward(4); + } else if (bEnableCode && sc.MatchIgnoreCase(".or.")) { + sc.SetState(SCE_FS_WORDOPERATOR); + sc.Forward(3); + } else if (bEnableCode && + (sc.MatchIgnoreCase(".t.") || sc.MatchIgnoreCase(".f.") || + (!IsAWordChar(sc.GetRelative(3)) && sc.MatchIgnoreCase("nil")))) { + sc.SetState(SCE_FS_CONSTANT); + sc.Forward(2); + } else if (sc.Match('/', '*')) { + sc.SetState(bEnableCode ? SCE_FS_COMMENTDOC : SCE_FS_COMMENTDOC_C); + sc.Forward(); + } else if (bEnableCode && sc.Match('&', '&')) { + sc.SetState(SCE_FS_COMMENTLINE); + sc.Forward(); + } else if (sc.Match('/', '/')) { + sc.SetState(bEnableCode ? SCE_FS_COMMENTLINEDOC : SCE_FS_COMMENTLINEDOC_C); + sc.Forward(); + } else if (bEnableCode && sc.ch == '*' && visibleChars == 0) { + sc.SetState(SCE_FS_COMMENT); + } else if (sc.ch == '\"' || sc.ch == '\'') { + sc.SetState(bEnableCode ? SCE_FS_STRING : SCE_FS_STRING_C); + closeStringChar = sc.ch; + } else if (closeStringChar == '>' && sc.ch == '<') { + sc.SetState(bEnableCode ? SCE_FS_STRING : SCE_FS_STRING_C); + } else if (sc.ch == '#' && visibleChars == 0) { + sc.SetState(bEnableCode ? SCE_FS_PREPROCESSOR : SCE_FS_PREPROCESSOR_C); + do { // Skip whitespace between # and preprocessor word + sc.Forward(); + } while (IsASpaceOrTab(sc.ch) && sc.More()); + if (sc.atLineEnd) { + sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C); + } else if (sc.MatchIgnoreCase("include")) { + if (stylingWithinPreprocessor) { + closeStringChar = '>'; + } + } else if (sc.MatchIgnoreCase("pragma")) { + sc.Forward(6); + do { // Skip more whitespace until keyword + sc.Forward(); + } while (IsASpaceOrTab(sc.ch) && sc.More()); + if (sc.MatchIgnoreCase("begindump") || sc.MatchIgnoreCase("__cstream")) { + bEnableCode = false; + if (stylingWithinPreprocessor) { + sc.SetState(SCE_FS_DISABLEDCODE); + sc.Forward(8); + sc.ForwardSetState(SCE_FS_DEFAULT_C); + } else { + sc.SetState(SCE_FS_DISABLEDCODE); + } + } else if (sc.MatchIgnoreCase("enddump") || sc.MatchIgnoreCase("__endtext")) { + bEnableCode = true; + sc.SetState(SCE_FS_DISABLEDCODE); + sc.Forward(sc.ch == '_' ? 8 : 6); + sc.ForwardSetState(SCE_FS_DEFAULT); + } + } + } else if (bEnableCode && sc.ch == '{') { + int p = 0; + int chSeek; + unsigned int endPos(startPos + length); + do { // Skip whitespace + chSeek = sc.GetRelative(++p); + } while (IsASpaceOrTab(chSeek) && (sc.currentPos + p < endPos)); + if (chSeek == '^') { + sc.SetState(SCE_FS_DATE); + } else { + sc.SetState(SCE_FS_OPERATOR); + } + } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(bEnableCode ? SCE_FS_NUMBER : SCE_FS_NUMBER_C); + } else if (IsAWordChar(sc.ch)) { + sc.SetState(bEnableCode ? SCE_FS_IDENTIFIER : SCE_FS_IDENTIFIER_C); + } else if (isoperator(static_cast(sc.ch)) || (bEnableCode && sc.ch == '@')) { + sc.SetState(bEnableCode ? SCE_FS_OPERATOR : SCE_FS_OPERATOR_C); + } + } + + if (sc.atLineEnd) { + visibleChars = 0; + closeStringChar = 0; + } + if (!IsASpace(sc.ch)) { + visibleChars++; + } + } + sc.Complete(); +} + +static void FoldFlagShipDoc(unsigned int startPos, int length, int, + WordList *[], Accessor &styler) +{ + + int endPos = startPos + length; + + // Backtrack to previous line in case need to fix its fold status + int lineCurrent = styler.GetLine(startPos); + if (startPos > 0 && lineCurrent > 0) { + lineCurrent--; + startPos = styler.LineStart(lineCurrent); + } + int spaceFlags = 0; + int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags); + char chNext = styler[startPos]; + for (int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + + if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == endPos-1)) { + int lev = indentCurrent; + int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags); + if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) { + if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) { + lev |= SC_FOLDLEVELHEADERFLAG; + } else if (indentNext & SC_FOLDLEVELWHITEFLAG) { + int spaceFlags2 = 0; + int indentNext2 = styler.IndentAmount(lineCurrent + 2, &spaceFlags2); + if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext2 & SC_FOLDLEVELNUMBERMASK)) { + lev |= SC_FOLDLEVELHEADERFLAG; + } + } + } + indentCurrent = indentNext; + styler.SetLevel(lineCurrent, lev); + lineCurrent++; + } + } +} + +static const char * const FSWordListDesc[] = { + "Keywords Commands", + "Std Library Functions", + "Procedure, return, exit", + "Class (oop)", + "Doxygen keywords", + 0 +}; + +LexerModule lmFlagShip(SCLEX_FLAGSHIP, ColouriseFlagShipDoc, "flagship", FoldFlagShipDoc, FSWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexForth.cxx b/sdk/wxscintilla/src/scintilla/src/LexForth.cxx new file mode 100644 index 0000000..e52543f --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexForth.cxx @@ -0,0 +1,176 @@ +// Scintilla source code edit control +/** @file LexForth.cxx + ** Lexer for FORTH + **/ +// Copyright 1998-2003 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsAWordChar(int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '.' || + ch == '_' || ch == '?' || ch == '"' || ch == '@' || + ch == '!' || ch == '[' || ch == ']' || ch == '/' || + ch == '+' || ch == '-' || ch == '*' || ch == '<' || + ch == '>' || ch == '=' || ch == ';' || ch == '(' || + ch == ')' ); +} + +static inline bool IsAWordStart(int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.'); +} + +static inline bool IsANumChar(int ch) { + return (ch < 0x80) && (isxdigit(ch) || ch == '.' || ch == 'e' || ch == 'E' ); +} + +static inline bool IsASpaceChar(int ch) { + return (ch < 0x80) && isspace(ch); +} + +static void ColouriseForthDoc(unsigned int startPos, int length, int initStyle, WordList *keywordLists[], + Accessor &styler) { + + WordList &control = *keywordLists[0]; + WordList &keyword = *keywordLists[1]; + WordList &defword = *keywordLists[2]; + WordList &preword1 = *keywordLists[3]; + WordList &preword2 = *keywordLists[4]; + WordList &strings = *keywordLists[5]; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) + { + // Determine if the current state should terminate. + if (sc.state == SCE_FORTH_COMMENT) { + if (sc.atLineEnd) { + sc.SetState(SCE_FORTH_DEFAULT); + } + }else if (sc.state == SCE_FORTH_COMMENT_ML) { + if (sc.ch == ')') { + sc.ForwardSetState(SCE_FORTH_DEFAULT); + } + }else if (sc.state == SCE_FORTH_IDENTIFIER || sc.state == SCE_FORTH_NUMBER) { + // handle numbers here too, because what we thought was a number might + // turn out to be a keyword e.g. 2DUP + if (IsASpaceChar(sc.ch) ) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + int newState = sc.state == SCE_FORTH_NUMBER ? SCE_FORTH_NUMBER : SCE_FORTH_DEFAULT; + if (control.InList(s)) { + sc.ChangeState(SCE_FORTH_CONTROL); + } else if (keyword.InList(s)) { + sc.ChangeState(SCE_FORTH_KEYWORD); + } else if (defword.InList(s)) { + sc.ChangeState(SCE_FORTH_DEFWORD); + } else if (preword1.InList(s)) { + sc.ChangeState(SCE_FORTH_PREWORD1); + } else if (preword2.InList(s)) { + sc.ChangeState(SCE_FORTH_PREWORD2); + } else if (strings.InList(s)) { + sc.ChangeState(SCE_FORTH_STRING); + newState = SCE_FORTH_STRING; + } + sc.SetState(newState); + } + if (sc.state == SCE_FORTH_NUMBER) { + if (IsASpaceChar(sc.ch)) { + sc.SetState(SCE_FORTH_DEFAULT); + } else if (!IsANumChar(sc.ch)) { + sc.ChangeState(SCE_FORTH_IDENTIFIER); + } + } + }else if (sc.state == SCE_FORTH_STRING) { + if (sc.ch == '\"') { + sc.ForwardSetState(SCE_FORTH_DEFAULT); + } + }else if (sc.state == SCE_FORTH_LOCALE) { + if (sc.ch == '}') { + sc.ForwardSetState(SCE_FORTH_DEFAULT); + } + }else if (sc.state == SCE_FORTH_DEFWORD) { + if (IsASpaceChar(sc.ch)) { + sc.SetState(SCE_FORTH_DEFAULT); + } + } + + // Determine if a new state should be entered. + if (sc.state == SCE_FORTH_DEFAULT) { + if (sc.ch == '\\'){ + sc.SetState(SCE_FORTH_COMMENT); + } else if (sc.ch == '(' && + (sc.atLineStart || IsASpaceChar(sc.chPrev)) && + (sc.atLineEnd || IsASpaceChar(sc.chNext))) { + sc.SetState(SCE_FORTH_COMMENT_ML); + } else if ( (sc.ch == '$' && (isascii(sc.chNext) && isxdigit(sc.chNext))) ) { + // number starting with $ is a hex number + sc.SetState(SCE_FORTH_NUMBER); + while(sc.More() && isascii(sc.chNext) && isxdigit(sc.chNext)) + sc.Forward(); + } else if ( (sc.ch == '%' && (isascii(sc.chNext) && (sc.chNext == '0' || sc.chNext == '1'))) ) { + // number starting with % is binary + sc.SetState(SCE_FORTH_NUMBER); + while(sc.More() && isascii(sc.chNext) && (sc.chNext == '0' || sc.chNext == '1')) + sc.Forward(); + } else if ( isascii(sc.ch) && + (isxdigit(sc.ch) || ((sc.ch == '.' || sc.ch == '-') && isascii(sc.chNext) && isxdigit(sc.chNext)) ) + ){ + sc.SetState(SCE_FORTH_NUMBER); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_FORTH_IDENTIFIER); + } else if (sc.ch == '{') { + sc.SetState(SCE_FORTH_LOCALE); + } else if (sc.ch == ':' && isascii(sc.chNext) && isspace(sc.chNext)) { + // highlight word definitions e.g. : GCD ( n n -- n ) ..... ; + // ^ ^^^ + sc.SetState(SCE_FORTH_DEFWORD); + while(sc.More() && isascii(sc.chNext) && isspace(sc.chNext)) + sc.Forward(); + } else if (sc.ch == ';' && + (sc.atLineStart || IsASpaceChar(sc.chPrev)) && + (sc.atLineEnd || IsASpaceChar(sc.chNext)) ) { + // mark the ';' that ends a word + sc.SetState(SCE_FORTH_DEFWORD); + sc.ForwardSetState(SCE_FORTH_DEFAULT); + } + } + + } + sc.Complete(); +} + +static void FoldForthDoc(unsigned int, int, int, WordList *[], + Accessor &) { +} + +static const char * const forthWordLists[] = { + "control keywords", + "keywords", + "definition words", + "prewords with one argument", + "prewords with two arguments", + "string definition keywords", + 0, + }; + +LexerModule lmForth(SCLEX_FORTH, ColouriseForthDoc, "forth", FoldForthDoc, forthWordLists); + + diff --git a/sdk/wxscintilla/src/scintilla/src/LexFortran.cxx b/sdk/wxscintilla/src/scintilla/src/LexFortran.cxx new file mode 100644 index 0000000..0b3f277 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexFortran.cxx @@ -0,0 +1,466 @@ +// Scintilla source code edit control +/** @file LexFortran.cxx + ** Lexer for Fortran. + ** Writen by Chuan-jian Shen, Last changed Sep. 2003 + **/ +// Copyright 1998-2001 by Neil Hodgson +// The License.txt file describes the conditions under which this software may be distributed. +/***************************************/ +#include +#include +#include +#include +#include +/***************************************/ +#include "Platform.h" +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +/***********************************************/ +static inline bool IsAWordChar(const int ch) { + return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '%'); +} +/**********************************************/ +static inline bool IsAWordStart(const int ch) { + return (ch < 0x80) && (isalnum(ch)); +} +/***************************************/ +inline bool IsABlank(unsigned int ch) { + return (ch == ' ') || (ch == 0x09) || (ch == 0x0b) ; +} +/***************************************/ +inline bool IsALineEnd(char ch) { + return ((ch == '\n') || (ch == '\r')) ; +} +/***************************************/ +unsigned int GetContinuedPos(unsigned int pos, Accessor &styler) { + while (!IsALineEnd(styler.SafeGetCharAt(pos++))) continue; + if (styler.SafeGetCharAt(pos) == '\n') pos++; + while (IsABlank(styler.SafeGetCharAt(pos++))) continue; + char chCur = styler.SafeGetCharAt(pos); + if (chCur == '&') { + while (IsABlank(styler.SafeGetCharAt(++pos))) continue; + return pos; + } else { + return pos; + } +} +/***************************************/ +static void ColouriseFortranDoc(unsigned int startPos, int length, int initStyle, + WordList *keywordlists[], Accessor &styler, bool isFixFormat) { + WordList &keywords = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + /***************************************/ + int posLineStart = 0, numNonBlank = 0, prevState = 0; + int endPos = startPos + length; + /***************************************/ + // backtrack to the nearest keyword + while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_F_WORD)) { + startPos--; + } + startPos = styler.LineStart(styler.GetLine(startPos)); + initStyle = styler.StyleAt(startPos - 1); + StyleContext sc(startPos, endPos-startPos, initStyle, styler); + /***************************************/ + for (; sc.More(); sc.Forward()) { + // remember the start position of the line + if (sc.atLineStart) { + posLineStart = sc.currentPos; + numNonBlank = 0; + sc.SetState(SCE_F_DEFAULT); + } + if (!IsASpaceOrTab(sc.ch)) numNonBlank ++; + /***********************************************/ + // Handle the fix format generically + int toLineStart = sc.currentPos - posLineStart; + if (isFixFormat && (toLineStart < 6 || toLineStart > 72)) { + if ((toLineStart == 0 && (tolower(sc.ch) == 'c' || sc.ch == '*')) || sc.ch == '!') { + if (sc.MatchIgnoreCase("cdec$") || sc.MatchIgnoreCase("*dec$") || sc.MatchIgnoreCase("!dec$") || + sc.MatchIgnoreCase("cdir$") || sc.MatchIgnoreCase("*dir$") || sc.MatchIgnoreCase("!dir$") || + sc.MatchIgnoreCase("cms$") || sc.MatchIgnoreCase("*ms$") || sc.MatchIgnoreCase("!ms$") || + sc.chNext == '$') { + sc.SetState(SCE_F_PREPROCESSOR); + } else { + sc.SetState(SCE_F_COMMENT); + } + + while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end + } else if (toLineStart > 72) { + sc.SetState(SCE_F_COMMENT); + while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end + } else if (toLineStart < 5) { + if (IsADigit(sc.ch)) + sc.SetState(SCE_F_LABEL); + else + sc.SetState(SCE_F_DEFAULT); + } else if (toLineStart == 5) { + if (!IsASpace(sc.ch) && sc.ch != '0') { + sc.SetState(SCE_F_CONTINUATION); + sc.ForwardSetState(prevState); + } else + sc.SetState(SCE_F_DEFAULT); + } + continue; + } + /***************************************/ + // Handle line continuation generically. + if (!isFixFormat && sc.ch == '&') { + char chTemp = ' '; + int j = 1; + while (IsABlank(chTemp) && j<132) { + chTemp = static_cast(sc.GetRelative(j)); + j++; + } + if (chTemp == '!') { + sc.SetState(SCE_F_CONTINUATION); + if (sc.chNext == '!') sc.ForwardSetState(SCE_F_COMMENT); + } else if (chTemp == '\r' || chTemp == '\n') { + int currentState = sc.state; + sc.SetState(SCE_F_CONTINUATION); + sc.ForwardSetState(SCE_F_DEFAULT); + while (IsASpace(sc.ch) && sc.More()) sc.Forward(); + if (sc.ch == '&') { + sc.SetState(SCE_F_CONTINUATION); + sc.Forward(); + } + sc.SetState(currentState); + } + } + /***************************************/ + // Determine if the current state should terminate. + if (sc.state == SCE_F_OPERATOR) { + sc.SetState(SCE_F_DEFAULT); + } else if (sc.state == SCE_F_NUMBER) { + if (!(IsAWordChar(sc.ch) || sc.ch=='\'' || sc.ch=='\"' || sc.ch=='.')) { + sc.SetState(SCE_F_DEFAULT); + } + } else if (sc.state == SCE_F_IDENTIFIER) { + if (!IsAWordChar(sc.ch) || (sc.ch == '%')) { + char s[100]; + sc.GetCurrentLowered(s, sizeof(s)); + if (keywords.InList(s)) { + sc.ChangeState(SCE_F_WORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_F_WORD2); + } else if (keywords3.InList(s)) { + sc.ChangeState(SCE_F_WORD3); + } + sc.SetState(SCE_F_DEFAULT); + } + } else if (sc.state == SCE_F_COMMENT || sc.state == SCE_F_PREPROCESSOR) { + if (sc.ch == '\r' || sc.ch == '\n') { + sc.SetState(SCE_F_DEFAULT); + } + } else if (sc.state == SCE_F_STRING1) { + prevState = sc.state; + if (sc.ch == '\'') { + if (sc.chNext == '\'') { + sc.Forward(); + } else { + sc.ForwardSetState(SCE_F_DEFAULT); + prevState = SCE_F_DEFAULT; + } + } else if (sc.atLineEnd) { + sc.ChangeState(SCE_F_STRINGEOL); + sc.ForwardSetState(SCE_F_DEFAULT); + } + } else if (sc.state == SCE_F_STRING2) { + prevState = sc.state; + if (sc.atLineEnd) { + sc.ChangeState(SCE_F_STRINGEOL); + sc.ForwardSetState(SCE_F_DEFAULT); + } else if (sc.ch == '\"') { + if (sc.chNext == '\"') { + sc.Forward(); + } else { + sc.ForwardSetState(SCE_F_DEFAULT); + prevState = SCE_F_DEFAULT; + } + } + } else if (sc.state == SCE_F_OPERATOR2) { + if (sc.ch == '.') { + sc.ForwardSetState(SCE_F_DEFAULT); + } + } else if (sc.state == SCE_F_CONTINUATION) { + sc.SetState(SCE_F_DEFAULT); + } else if (sc.state == SCE_F_LABEL) { + if (!IsADigit(sc.ch)) { + sc.SetState(SCE_F_DEFAULT); + } else { + if (isFixFormat && sc.currentPos-posLineStart > 4) + sc.SetState(SCE_F_DEFAULT); + else if (numNonBlank > 5) + sc.SetState(SCE_F_DEFAULT); + } + } + /***************************************/ + // Determine if a new state should be entered. + if (sc.state == SCE_F_DEFAULT) { + if (sc.ch == '!') { + if (sc.MatchIgnoreCase("!dec$") || sc.MatchIgnoreCase("!dir$") || + sc.MatchIgnoreCase("!ms$") || sc.chNext == '$') { + sc.SetState(SCE_F_PREPROCESSOR); + } else { + sc.SetState(SCE_F_COMMENT); + } + } else if ((!isFixFormat) && IsADigit(sc.ch) && numNonBlank == 1) { + sc.SetState(SCE_F_LABEL); + } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { + sc.SetState(SCE_F_NUMBER); + } else if ((tolower(sc.ch) == 'b' || tolower(sc.ch) == 'o' || + tolower(sc.ch) == 'z') && (sc.chNext == '\"' || sc.chNext == '\'')) { + sc.SetState(SCE_F_NUMBER); + sc.Forward(); + } else if (sc.ch == '.' && isalpha(sc.chNext)) { + sc.SetState(SCE_F_OPERATOR2); + } else if (IsAWordStart(sc.ch)) { + sc.SetState(SCE_F_IDENTIFIER); + } else if (sc.ch == '\"') { + sc.SetState(SCE_F_STRING2); + } else if (sc.ch == '\'') { + sc.SetState(SCE_F_STRING1); + } else if (isoperator(static_cast(sc.ch))) { + sc.SetState(SCE_F_OPERATOR); + } + } + } + sc.Complete(); +} +/***************************************/ +// To determine the folding level depending on keywords +static int classifyFoldPointFortran(const char* s, const char* prevWord, const char chNextNonBlank) { + int lev = 0; + if ((strcmp(prevWord, "else") == 0 && strcmp(s, "if") == 0) || strcmp(s, "elseif") == 0) + return -1; + if (strcmp(s, "associate") == 0 || strcmp(s, "block") == 0 + || strcmp(s, "blockdata") == 0 || strcmp(s, "select") == 0 + || strcmp(s, "do") == 0 || strcmp(s, "enum") ==0 + || strcmp(s, "function") == 0 || strcmp(s, "interface") == 0 + || strcmp(s, "module") == 0 || strcmp(s, "program") == 0 + || strcmp(s, "subroutine") == 0 || strcmp(s, "then") == 0 + || (strcmp(s, "type") == 0 && chNextNonBlank != '(') ){ + if (strcmp(prevWord, "end") == 0) + lev = 0; + else + lev = 1; + } else if ((strcmp(s, "end") == 0 && chNextNonBlank != '=') + || strcmp(s, "endassociate") == 0 || strcmp(s, "endblock") == 0 + || strcmp(s, "endblockdata") == 0 || strcmp(s, "endselect") == 0 + || strcmp(s, "enddo") == 0 || strcmp(s, "endenum") ==0 + || strcmp(s, "endif") == 0 || strcmp(s, "endforall") == 0 + || strcmp(s, "endfunction") == 0 || strcmp(s, "endinterface") == 0 + || strcmp(s, "endmodule") == 0 || strcmp(s, "endprogram") == 0 + || strcmp(s, "endsubroutine") == 0 || strcmp(s, "endtype") == 0 + || strcmp(s, "endwhere") == 0 + || strcmp(s, "procedure") == 0 ) { // Take care of the module procedure statement + lev = -1; + } else if (strcmp(prevWord, "end") == 0 && strcmp(s, "if") == 0){ // end if + lev = 0; + } + return lev; +} +// Folding the code +static void FoldFortranDoc(unsigned int startPos, int length, int initStyle, + Accessor &styler, bool isFixFormat) { + // + // bool foldComment = styler.GetPropertyInt("fold.comment") != 0; + // Do not know how to fold the comment at the moment. + // + bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + char chNextNonBlank; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + /***************************************/ + int lastStart = 0; + char prevWord[32] = ""; + char Label[6] = ""; + // Variables for do label folding. + static int doLabels[100]; + static int posLabel=-1; + /***************************************/ + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + chNextNonBlank = chNext; + unsigned int j=i+1; + while(IsABlank(chNextNonBlank) && j(tolower(styler[lastStart+k])); + } + s[k] = '\0'; + // Handle the forall and where statement and structure. + if (strcmp(s, "forall") == 0 || strcmp(s, "where") == 0) { + if (strcmp(prevWord, "end") != 0) { + j = i + 1; + char chBrace = '(', chSeek = ')', ch1 = styler.SafeGetCharAt(j); + // Find the position of the first ( + while (ch1 != chBrace && j -1) { + levelCurrent--; + posLabel--; + } + } + } + if (atEOL) { + int lev = levelPrev; + if (visibleChars == 0 && foldCompact) + lev |= SC_FOLDLEVELWHITEFLAG; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + strcpy(prevWord, ""); + } + /***************************************/ + if (!isspacechar(ch)) visibleChars++; + } + /***************************************/ + // Fill in the real level of the next line, keeping the current flags as they will be filled in later + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} +/***************************************/ +static const char * const FortranWordLists[] = { + "Primary keywords and identifiers", + "Intrinsic functions", + "Extended and user defined functions", + 0, +}; +/***************************************/ +static void ColouriseFortranDocFreeFormat(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + ColouriseFortranDoc(startPos, length, initStyle, keywordlists, styler, false); +} +/***************************************/ +static void ColouriseFortranDocFixFormat(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], + Accessor &styler) { + ColouriseFortranDoc(startPos, length, initStyle, keywordlists, styler, true); +} +/***************************************/ +static void FoldFortranDocFreeFormat(unsigned int startPos, int length, int initStyle, + WordList *[], Accessor &styler) { + FoldFortranDoc(startPos, length, initStyle,styler, false); +} +/***************************************/ +static void FoldFortranDocFixFormat(unsigned int startPos, int length, int initStyle, + WordList *[], Accessor &styler) { + FoldFortranDoc(startPos, length, initStyle,styler, true); +} +/***************************************/ +LexerModule lmFortran(SCLEX_FORTRAN, ColouriseFortranDocFreeFormat, "fortran", FoldFortranDocFreeFormat, FortranWordLists); +LexerModule lmF77(SCLEX_F77, ColouriseFortranDocFixFormat, "f77", FoldFortranDocFixFormat, FortranWordLists); diff --git a/sdk/wxscintilla/src/scintilla/src/LexGAP.cxx b/sdk/wxscintilla/src/scintilla/src/LexGAP.cxx new file mode 100644 index 0000000..fb6e739 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexGAP.cxx @@ -0,0 +1,263 @@ +// Scintilla source code edit control +/** @file LexGAP.cxx + ** Lexer for the GAP language. (The GAP System for Computational Discrete Algebra) + ** http://www.gap-system.org + **/ +// Copyright 2007 by Istvan Szollosi ( szteven gmail com ) +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "StyleContext.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +static inline bool IsGAPOperator(char ch) { + if (isascii(ch) && isalnum(ch)) return false; + if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || + ch == '^' || ch == ',' || ch == '!' || ch == '.' || + ch == '=' || ch == '<' || ch == '>' || ch == '(' || + ch == ')' || ch == ';' || ch == '[' || ch == ']' || + ch == '{' || ch == '}' || ch == ':' ) + return true; + return false; +} + +static void GetRange(unsigned int start, unsigned int end, Accessor &styler, char *s, unsigned int len) { + unsigned int i = 0; + while ((i < end - start + 1) && (i < len-1)) { + s[i] = static_cast(styler[start + i]); + i++; + } + s[i] = '\0'; +} + +static void ColouriseGAPDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) { + + WordList &keywords1 = *keywordlists[0]; + WordList &keywords2 = *keywordlists[1]; + WordList &keywords3 = *keywordlists[2]; + WordList &keywords4 = *keywordlists[3]; + + // Do not leak onto next line + if (initStyle == SCE_GAP_STRINGEOL) initStyle = SCE_GAP_DEFAULT; + + StyleContext sc(startPos, length, initStyle, styler); + + for (; sc.More(); sc.Forward()) { + + // Prevent SCE_GAP_STRINGEOL from leaking back to previous line + if ( sc.atLineStart ) { + if (sc.state == SCE_GAP_STRING) sc.SetState(SCE_GAP_STRING); + if (sc.state == SCE_GAP_CHAR) sc.SetState(SCE_GAP_CHAR); + } + + // Handle line continuation generically + if (sc.ch == '\\' ) { + if (sc.chNext == '\n' || sc.chNext == '\r') { + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + continue; + } + } + + // Determine if the current state should terminate + switch (sc.state) { + case SCE_GAP_OPERATOR : + sc.SetState(SCE_GAP_DEFAULT); + break; + + case SCE_GAP_NUMBER : + if (!IsADigit(sc.ch)) { + if (sc.ch == '\\') { + if (!sc.atLineEnd) { + if (!IsADigit(sc.chNext)) { + sc.Forward(); + sc.ChangeState(SCE_GAP_IDENTIFIER); + } + } + } else if (isalpha(sc.ch) || sc.ch == '_') { + sc.ChangeState(SCE_GAP_IDENTIFIER); + } + else sc.SetState(SCE_GAP_DEFAULT); + } + break; + + case SCE_GAP_IDENTIFIER : + if (!(iswordstart(static_cast(sc.ch)) || sc.ch == '$')) { + if (sc.ch == '\\') sc.Forward(); + else { + char s[1000]; + sc.GetCurrent(s, sizeof(s)); + if (keywords1.InList(s)) { + sc.ChangeState(SCE_GAP_KEYWORD); + } else if (keywords2.InList(s)) { + sc.ChangeState(SCE_GAP_KEYWORD2); + } else if (keywords3.InList(s)) { + sc.ChangeState(SCE_GAP_KEYWORD3); + } else if (keywords4.InList(s)) { + sc.ChangeState(SCE_GAP_KEYWORD4); + } + sc.SetState(SCE_GAP_DEFAULT); + } + } + break; + + case SCE_GAP_COMMENT : + if (sc.atLineEnd) { + sc.SetState(SCE_GAP_DEFAULT); + } + break; + + case SCE_GAP_STRING: + if (sc.atLineEnd) { + sc.ChangeState(SCE_GAP_STRINGEOL); + } else if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\"') { + sc.ForwardSetState(SCE_GAP_DEFAULT); + } + break; + + case SCE_GAP_CHAR: + if (sc.atLineEnd) { + sc.ChangeState(SCE_GAP_STRINGEOL); + } else if (sc.ch == '\\') { + if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') { + sc.Forward(); + } + } else if (sc.ch == '\'') { + sc.ForwardSetState(SCE_GAP_DEFAULT); + } + break; + + case SCE_GAP_STRINGEOL: + if (sc.atLineStart) { + sc.SetState(SCE_GAP_DEFAULT); + } + break; + } + + // Determine if a new state should be entered + if (sc.state == SCE_GAP_DEFAULT) { + if (IsGAPOperator(static_cast(sc.ch))) { + sc.SetState(SCE_GAP_OPERATOR); + } + else if (IsADigit(sc.ch)) { + sc.SetState(SCE_GAP_NUMBER); + } else if (isalpha(sc.ch) || sc.ch == '_' || sc.ch == '\\' || sc.ch == '$' || sc.ch == '~') { + sc.SetState(SCE_GAP_IDENTIFIER); + if (sc.ch == '\\') sc.Forward(); + } else if (sc.ch == '#') { + sc.SetState(SCE_GAP_COMMENT); + } else if (sc.ch == '\"') { + sc.SetState(SCE_GAP_STRING); + } else if (sc.ch == '\'') { + sc.SetState(SCE_GAP_CHAR); + } + } + + } + sc.Complete(); +} + +static int ClassifyFoldPointGAP(const char* s) { + int level = 0; + if (strcmp(s, "function") == 0 || + strcmp(s, "do") == 0 || + strcmp(s, "if") == 0 || + strcmp(s, "repeat") == 0 ) { + level = 1; + } else if (strcmp(s, "end") == 0 || + strcmp(s, "od") == 0 || + strcmp(s, "fi") == 0 || + strcmp(s, "until") == 0 ) { + level = -1; + } + return level; +} + +static void FoldGAPDoc( unsigned int startPos, int length, int initStyle, WordList** , Accessor &styler) { + unsigned int endPos = startPos + length; + int visibleChars = 0; + int lineCurrent = styler.GetLine(startPos); + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; + int levelCurrent = levelPrev; + char chNext = styler[startPos]; + int styleNext = styler.StyleAt(startPos); + int style = initStyle; + + int lastStart = 0; + + for (unsigned int i = startPos; i < endPos; i++) { + char ch = chNext; + chNext = styler.SafeGetCharAt(i + 1); + int stylePrev = style; + style = styleNext; + styleNext = styler.StyleAt(i + 1); + bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + + if (stylePrev != SCE_GAP_KEYWORD && style == SCE_GAP_KEYWORD) { + // Store last word start point. + lastStart = i; + } + + if (stylePrev == SCE_GAP_KEYWORD) { + if(iswordchar(ch) && !iswordchar(chNext)) { + char s[100]; + GetRange(lastStart, i, styler, s, sizeof(s)); + levelCurrent += ClassifyFoldPointGAP(s); + } + } + + if (atEOL) { + int lev = levelPrev; + if ((levelCurrent > levelPrev) && (visibleChars > 0)) + lev |= SC_FOLDLEVELHEADERFLAG; + if (lev != styler.LevelAt(lineCurrent)) { + styler.SetLevel(lineCurrent, lev); + } + lineCurrent++; + levelPrev = levelCurrent; + visibleChars = 0; + } + + if (!isspacechar(ch)) + visibleChars++; + } + + int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK; + styler.SetLevel(lineCurrent, levelPrev | flagsNext); +} + +static const char * const GAPWordListDesc[] = { + "Keywords 1", + "Keywords 2", + "Keywords 3 (unused)", + "Keywords 4 (unused)", + 0 +}; + +LexerModule lmGAP( + SCLEX_GAP, + ColouriseGAPDoc, + "gap", + FoldGAPDoc, + GAPWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexGCC.cxx b/sdk/wxscintilla/src/scintilla/src/LexGCC.cxx new file mode 100644 index 0000000..3a96b4d --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexGCC.cxx @@ -0,0 +1,119 @@ +// Scintilla source code edit control +/** @file LexOthers.cxx + ** Lexers for batch files, diff results, properties files, make files and error lists. + ** Also lexer for LaTeX documents. + **/ +// Copyright 1998-2001 by Eran Ifrah +// The License.txt file describes the conditions under which this software may be distributed. + +#include +#include +#include +#include +#include +#include +#include + +#include "Platform.h" + +#include "PropSet.h" +#include "Accessor.h" +#include "KeyWords.h" +#include "Scintilla.h" +#include "SciLexer.h" +#include "StyleContext.h" + +#ifdef SCI_NAMESPACE +using namespace Scintilla; +#endif + +typedef int (*GCC_COLOUR_FUNC_PTR)(int, const char*, size_t&, size_t&); + +static GCC_COLOUR_FUNC_PTR s_gccColourFunc = NULL; + +void SetGccColourFunction(GCC_COLOUR_FUNC_PTR func) +{ + s_gccColourFunc = func; +} + +static inline bool AtEOL(Accessor &styler, unsigned int i) +{ + return (styler[i] == '\n') || + ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n')); +} + +static void ColouriseGccDoc( + unsigned int pos, + int length, + int /*initStyle*/, + WordList * /*keywordlists*/[], + Accessor &styler) +{ + std::string line; + line.reserve(2048); + + styler.StartAt(pos); + styler.StartSegment(pos); + + for (; length > 0; pos++, length--) { + line += styler[pos]; + if (AtEOL(styler, pos)) { + // End of line met, colourise it + int style = SCLEX_GCC_OUTPUT; + if (s_gccColourFunc) { + size_t start(0); + size_t len(0); + int startLine = pos-line.size()+1; + style = s_gccColourFunc(startLine, line.c_str(), start, len); + if(len != 0) { + styler.ColourTo(startLine + start - 1, style); + styler.ColourTo(startLine + start + len - 1, SCLEX_GCC_FILE_LINK); + } + } + styler.ColourTo(pos, style); + line.clear(); + } + } +} + +static void FoldGccDoc(unsigned int pos, int length, int, + WordList*[], Accessor &styler) +{ + int curLine = styler.GetLine(pos); + int prevLevel = curLine > 0 ? styler.LevelAt(curLine-1) : SC_FOLDLEVELBASE; + + unsigned int end = pos+length; + pos = styler.LineStart(curLine); + + do { + int nextLevel; + switch (styler.StyleAt(pos)) { + case SCLEX_GCC_BUILDING: + nextLevel = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG; + break; + default: + nextLevel = prevLevel & SC_FOLDLEVELHEADERFLAG ? (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1 : prevLevel; + break; + } + if ((nextLevel & SC_FOLDLEVELHEADERFLAG) && nextLevel == prevLevel) { + styler.SetLevel(curLine-1, prevLevel & ~SC_FOLDLEVELHEADERFLAG); + } + styler.SetLevel(curLine, nextLevel); + + curLine++; + prevLevel = nextLevel; + pos = styler.LineStart(curLine); + } while (pos < end); +} + +static const char * const gccWordListDesc[] = { + "Internal Commands", + "External Commands", + 0 +}; + +static const char * const emptyWordListDesc[] = { + 0 +}; + +LexerModule lmGcc(SCLEX_GCC, ColouriseGccDoc, "gcc", FoldGccDoc, gccWordListDesc); diff --git a/sdk/wxscintilla/src/scintilla/src/LexGen.py b/sdk/wxscintilla/src/scintilla/src/LexGen.py new file mode 100644 index 0000000..c5ea800 --- /dev/null +++ b/sdk/wxscintilla/src/scintilla/src/LexGen.py @@ -0,0 +1,287 @@ +# LexGen.py - implemented 2002 by Neil Hodgson neilh@scintilla.org +# Released to the public domain. + +# Regenerate the Scintilla and SciTE source files that list +# all the lexers and all the properties files. +# Should be run whenever a new lexer is added or removed. +# Requires Python 2.4 or later +# Most files are regenerated in place with templates stored in comments. +# The VS .NET project file is generated into a different file as the +# VS .NET environment will not retain comments when modifying the file. +# The files are copied to a string apart from sections between a +# ++Autogenerated comment and a --Autogenerated comment which is +# generated by the CopyWithInsertion function. After the whole +# string is instantiated, it is compared with the target file and +# if different the file is rewritten. +# Does not regenerate the Visual C++ 6 project files but does the VS .NET +# project file. + +import string +import sys +import os +import glob + +# EOL constants +CR = "\r" +LF = "\n" +CRLF = "\r\n" +if sys.platform == "win32": + NATIVE = CRLF +else: + # Yes, LF is the native EOL even on Mac OS X. CR is just for + # Mac OS <=9 (a.k.a. "Mac Classic") + NATIVE = LF + +# Automatically generated sections contain start and end comments, +# a definition line and the results. +# The results are replaced by regenerating based on the definition line. +# The definition line is a comment prefix followed by "**". +# If there is a digit after the ** then this indicates which list to use +# and the digit and next character are not part of the definition +# Backslash is used as an escape within the definition line. +# The part between \( and \) is repeated for each item in the list. +# \* is replaced by each list item. \t, and \n are tab and newline. +def CopyWithInsertion(input, commentPrefix, retainDefs, eolType, *lists): + copying = 1 + listid = 0 + output = [] + for line in input.splitlines(0): + isStartGenerated = line.startswith(commentPrefix + "++Autogenerated") + if copying and not isStartGenerated: + output.append(line) + if isStartGenerated: + if retainDefs: + output.append(line) + copying = 0 + definition = "" + elif not copying and line.startswith(commentPrefix + "**"): + if retainDefs: + output.append(line) + definition = line[len(commentPrefix + "**"):] + if (commentPrefix == "" in definition): + definition = definition.replace(" -->", "") + listid = 0 + if definition[0] in string.digits: + listid = int(definition[:1]) + definition = definition[2:] + # Hide double slashes as a control character + definition = definition.replace("\\\\", "\001") + # Do some normal C style transforms + definition = definition.replace("\\n", "\n") + definition = definition.replace("\\t", "\t") + # Get the doubled backslashes back as single backslashes + definition = definition.replace("\001", "\\") + startRepeat = definition.find("\\(") + endRepeat = definition.find("\\)") + intro = definition[:startRepeat] + out = "" + if intro.endswith("\n"): + pos = 0 + else: + pos = len(intro) + out += intro + middle = definition[startRepeat+2:endRepeat] + for i in lists[listid]: + item = middle.replace("\\*", i) + if pos and (pos + len(item) >= 80): + out += "\\\n" + pos = 0 + out += item + pos += len(item) + if item.endswith("\n"): + pos = 0 + outro = definition[endRepeat+2:] + out += outro + out = out.replace("\n", eolType) # correct EOLs in generated content + output.append(out) + elif line.startswith(commentPrefix + "--Autogenerated"): + copying = 1 + if retainDefs: + output.append(line) + output = [line.rstrip(" \t") for line in output] # trim trailing whitespace + return eolType.join(output) + eolType + +def UpdateFile(filename, updated): + """ If the file is different to updated then copy updated + into the file else leave alone so CVS and make don't treat + it as modified. """ + try: + infile = open(filename, "rb") + except IOError: # File is not there yet + out = open(filename, "wb") + out.write(updated.encode('utf-8')) + out.close() + print("New %s" % filename) + return + original = infile.read() + infile.close() + original = original.decode('utf-8') + if updated != original: + os.unlink(filename) + out = open(filename, "wb") + out.write(updated.encode('utf-8')) + out.close() + print("Changed %s " % filename) + #~ else: + #~ print "Unchanged", filename + +def Generate(inpath, outpath, commentPrefix, eolType, *lists): + """Generate 'outpath' from 'inpath'. + + "eolType" indicates the type of EOLs to use in the generated + file. It should be one of following constants: LF, CRLF, + CR, or NATIVE. + """ + #print "generate '%s' -> '%s' (comment prefix: %r, eols: %r)"\ + # % (inpath, outpath, commentPrefix, eolType) + try: + infile = open(inpath, "rb") + except IOError: + print("Can not open %s" % inpath) + return + original = infile.read() + infile.close() + original = original.decode('utf-8') + updated = CopyWithInsertion(original, commentPrefix, + inpath == outpath, eolType, *lists) + UpdateFile(outpath, updated) + +def Regenerate(filename, commentPrefix, eolType, *lists): + """Regenerate the given file. + + "eolType" indicates the type of EOLs to use in the generated + file. It should be one of following constants: LF, CRLF, + CR, or NATIVE. + """ + Generate(filename, filename, commentPrefix, eolType, *lists) + +def FindModules(lexFile): + modules = [] + f = open(lexFile) + for l in f.readlines(): + if l.startswith("LexerModule"): + l = l.replace("(", " ") + modules.append(l.split()[1]) + return modules + +knownIrregularProperties = [ + "fold", + "styling.within.preprocessor", + "tab.timmy.whinge.level", + "asp.default.language", + "html.tags.case.sensitive", + "ps.level", + "ps.tokenize", + "sql.backslash.escapes", + "nsis.uservars", + "nsis.ignorecase" +] + +def FindProperties(lexFile): + properties = {} + f = open(lexFile) + for l in f.readlines(): + if "GetProperty" in l and '"' in l: + l = l.strip() + if not l.startswith("//"): # Drop comments + propertyName = l.split("\"")[1] + if propertyName.lower() == propertyName: + # Only allow lower case property names + if propertyName in knownIrregularProperties or \ + propertyName.startswith("fold.") or \ + propertyName.startswith("lexer."): + properties[propertyName] = 1 + return properties + +def FindPropertyDocumentation(lexFile): + documents = {} + f = open(lexFile) + name = "" + for l in f.readlines(): + l = l.strip() + if "// property " in l: + propertyName = l.split()[2] + if propertyName.lower() == propertyName: + # Only allow lower case property names + name = propertyName + documents[name] = "" + elif name: + if l.startswith("//"): + if documents[name]: + documents[name] += " " + documents[name] += l[2:].strip() + else: + name = "" + return documents + +def ciCompare(a,b): + return cmp(a.lower(), b.lower()) + +def ciKey(a): + return a.lower() + +def sortListInsensitive(l): + try: # Try key function + l.sort(key=ciKey) + except TypeError: # Earlier version of Python, so use comparison function + l.sort(ciCompare) + +def RegenerateAll(): + root="../../" + + # Find all the lexer source code files + lexFilePaths = glob.glob(root + "scintilla/src/Lex*.cxx") + sortListInsensitive(lexFilePaths) + lexFiles = [os.path.basename(f)[:-4] for f in lexFilePaths] + print(lexFiles) + lexerModules = [] + lexerProperties = {} + propertyDocuments = {} + for lexFile in lexFilePaths: + lexerModules.extend(FindModules(lexFile)) + for k in FindProperties(lexFile).keys(): + lexerProperties[k] = 1 + documents = FindPropertyDocumentation(lexFile) + for k in documents.keys(): + propertyDocuments[k] = documents[k] + sortListInsensitive(lexerModules) + del lexerProperties["fold.comment.python"] + lexerProperties = list(lexerProperties.keys()) + sortListInsensitive(lexerProperties) + + # Generate HTML to document each property + # This is done because tags can not be safely put inside comments in HTML + documentProperties = list(propertyDocuments.keys()) + sortListInsensitive(documentProperties) + propertiesHTML = [] + for k in documentProperties: + propertiesHTML.append("\t\n\t%s\n\t%s\n\t" % + (k, propertyDocuments[k])) + + # Find all the SciTE properties files + otherProps = ["abbrev.properties", "Embedded.properties", "SciTEGlobal.properties", "SciTE.properties"] + if os.path.exists(root + "scite"): + propFilePaths = glob.glob(root + "scite/src/*.properties") + sortListInsensitive(propFilePaths) + propFiles = [os.path.basename(f) for f in propFilePaths if os.path.basename(f) not in otherProps] + sortListInsensitive(propFiles) + print(propFiles) + + Regenerate(root + "scintilla/src/KeyWords.cxx", "//", NATIVE, lexerModules) + Regenerate(root + "scintilla/win32/makefile", "#", NATIVE, lexFiles) + Regenerate(root + "scintilla/win32/scintilla.mak", "#", NATIVE, lexFiles) + Regenerate(root + "scintilla/win32/scintilla_vc6.mak", "#", NATIVE, lexFiles) + # Use Unix EOLs for gtk Makefiles so they work for Linux users when + # extracted from the Scintilla source ZIP (typically created on + # Windows). + Regenerate(root + "scintilla/gtk/makefile", "#", LF, lexFiles) + Regenerate(root + "scintilla/macosx/makefile", "#", LF, lexFiles) + if os.path.exists(root + "scite"): + Regenerate(root + "scite/win32/makefile", "#", NATIVE, lexFiles, propFiles) + Regenerate(root + "scite/win32/scite.mak", "#", NATIVE, lexFiles, propFiles) + Regenerate(root + "scite/src/SciTEProps.cxx", "//", NATIVE, lexerProperties) + Regenerate(root + "scite/doc/SciTEDoc.html", "